dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 440
 441 #include <dali-toolkit/devel-api/builder/builder.h>
 442
 443 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 444 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 445
 446 #include <dali-toolkit/devel-api/controls/control-devel.h>
 447 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 448 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 449 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 453 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 454
 455 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 456 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 457 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 458
 459 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 460 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 462
 463 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 464 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 465 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 470 #include <dali/devel-api/adaptor-framework/image-loading.h>
 471
 472 #include <dali/public-api/events/mouse-button.h>
 473
 474 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 475 #include "web-view-signal-converter.h"
 476
 477 #include <dali/integration-api/debug.h>
 478
 479 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 480
 481 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 482
 483
 484 // add here SWIG version check
 485
 486 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 487 // disable Swig-dependent warnings
 488
 489 // 'identifier1' has C-linkage specified,
 490 // but returns UDT 'identifier2' which is incompatible with C
 491 #pragma warning(disable: 4190)
 492
 493 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 494 #pragma warning(disable: 4800)
 495
 496 // debug info too long etc etc
 497 #pragma warning(disable: 4786)
 498 #endif
 499
 500
 501 #include <stdexcept>
 502
 503
 504 #include <string>
 505
 506
 507 #include <vector>
 508 #include <algorithm>
 509 #include <stdexcept>
 510
 511
 512 #include <map>
 513 #include <algorithm>
 514 #include <stdexcept>
 515
 516
 517 #include <utility>
 518
 519
 520 typedef float floatp;
 521
 522 SWIGINTERN floatp *new_floatp(){
 523   return new float();
 524 }
 525 SWIGINTERN void delete_floatp(floatp *self){
 526   if (self) delete self;
 527 }
 528 SWIGINTERN void floatp_assign(floatp *self,float value){
 529   *self = value;
 530 }
 531 SWIGINTERN float floatp_value(floatp *self){
 532   return *self;
 533 }
 534 SWIGINTERN float *floatp_cast(floatp *self){
 535   return self;
 536 }
 537 SWIGINTERN floatp *floatp_frompointer(float *t){
 538   return (floatp *) t;
 539 }
 540
 541 typedef int intp;
 542
 543 SWIGINTERN intp *new_intp(){
 544   return new int();
 545 }
 546 SWIGINTERN void delete_intp(intp *self){
 547   if (self) delete self;
 548 }
 549 SWIGINTERN void intp_assign(intp *self,int value){
 550   *self = value;
 551 }
 552 SWIGINTERN int intp_value(intp *self){
 553   return *self;
 554 }
 555 SWIGINTERN int *intp_cast(intp *self){
 556   return self;
 557 }
 558 SWIGINTERN intp *intp_frompointer(int *t){
 559   return (intp *) t;
 560 }
 561
 562 typedef double doublep;
 563
 564 SWIGINTERN doublep *new_doublep(){
 565   return new double();
 566 }
 567 SWIGINTERN void delete_doublep(doublep *self){
 568   if (self) delete self;
 569 }
 570 SWIGINTERN void doublep_assign(doublep *self,double value){
 571   *self = value;
 572 }
 573 SWIGINTERN double doublep_value(doublep *self){
 574   return *self;
 575 }
 576 SWIGINTERN double *doublep_cast(doublep *self){
 577   return self;
 578 }
 579 SWIGINTERN doublep *doublep_frompointer(double *t){
 580   return (doublep *) t;
 581 }
 582
 583 typedef unsigned int uintp;
 584
 585 SWIGINTERN uintp *new_uintp(){
 586   return new unsigned int();
 587 }
 588 SWIGINTERN void delete_uintp(uintp *self){
 589   if (self) delete self;
 590 }
 591 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 592   *self = value;
 593 }
 594 SWIGINTERN unsigned int uintp_value(uintp *self){
 595   return *self;
 596 }
 597 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 598   return self;
 599 }
 600 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 601   return (uintp *) t;
 602 }
 603
 604 typedef unsigned short ushortp;
 605
 606 SWIGINTERN ushortp *new_ushortp(){
 607   return new unsigned short();
 608 }
 609 SWIGINTERN void delete_ushortp(ushortp *self){
 610   if (self) delete self;
 611 }
 612 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 613   *self = value;
 614 }
 615 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 616   return *self;
 617 }
 618 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 619   return self;
 620 }
 621 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 622   return (ushortp *) t;
 623 }
 624
 625 unsigned int int_to_uint(int x) {
 626    return (unsigned int) x;
 627 }
 628
 629
 630 using namespace Dali;
 631 using namespace Dali::Toolkit;
 632
 633 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 634 {
 635   bool result = false;
 636   try
 637   {
 638     // C++ code. DALi uses Handle <-> Body design pattern.
 639     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 640     // Handles in DALi can be converted into a boolean type
 641     // to check if the handle has a valid body attached to it.
 642     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 643     if( *self )
 644     {
 645       result = true;
 646     }
 647     else
 648     {
 649       result = false;
 650     }
 651   }
 652   catch (std::out_of_range& e)
 653   {
 654     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 655     return 0;
 656   }
 657   catch (std::exception& e)
 658   {
 659     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 660     return 0;
 661   }
 662   catch (DaliException e)
 663   {
 664     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 665     return 0;
 666   }
 667   catch (...)
 668   {
 669     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 670     return 0;
 671   }
 672   return result;
 673 }
 674
 675 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 676 {
 677   bool result = false;
 678   try
 679   {
 680     // C++ code. Check if two handles reference the same implemtion
 681     if( *self == rhs)
 682     {
 683       result = true;
 684     }
 685     else
 686     {
 687       result = false;
 688     }
 689   }
 690   catch (std::out_of_range& e)
 691   {
 692     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 693     return 0;
 694   }
 695   catch (std::exception& e)
 696   {
 697     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 698     return 0;
 699   }
 700   catch (DaliException e)
 701   {
 702     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 703     return 0;
 704   }
 705   catch (...)
 706   {
 707     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 708     return 0;
 709   }
 710   return result;
 711 }
 712
 713
 714 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 715      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 716    }
 717 SWIGINTERN void Dali_TypeRegistration_RegisterProperty(std::string const &controlName,std::string const &propertyName,int index,Dali::Property::Type type,Dali::CSharpTypeInfo::SetPropertyFunction setFunc,Dali::CSharpTypeInfo::GetPropertyFunction getFunc){
 718      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 719    }
 720 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 721         std::vector< Dali::TouchPoint >* pv = 0;
 722         if (capacity >= 0) {
 723           pv = new std::vector< Dali::TouchPoint >();
 724           pv->reserve(capacity);
 725        } else {
 726           throw std::out_of_range("capacity");
 727        }
 728        return pv;
 729       }
 730 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 731         if (index>=0 && index<(int)self->size())
 732           return (*self)[index];
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 737         if (index>=0 && index<(int)self->size())
 738           return (*self)[index];
 739         else
 740           throw std::out_of_range("index");
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 743         if (index>=0 && index<(int)self->size())
 744           (*self)[index] = val;
 745         else
 746           throw std::out_of_range("index");
 747       }
 748 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 749         self->insert(self->end(), values.begin(), values.end());
 750       }
 751 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 752         if (index < 0)
 753           throw std::out_of_range("index");
 754         if (count < 0)
 755           throw std::out_of_range("count");
 756         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 757           throw std::invalid_argument("invalid range");
 758         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 761         if (index>=0 && index<(int)self->size()+1)
 762           self->insert(self->begin()+index, x);
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 767         if (index>=0 && index<(int)self->size()+1)
 768           self->insert(self->begin()+index, values.begin(), values.end());
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 773         if (index>=0 && index<(int)self->size())
 774           self->erase(self->begin() + index);
 775         else
 776           throw std::out_of_range("index");
 777       }
 778 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 779         if (index < 0)
 780           throw std::out_of_range("index");
 781         if (count < 0)
 782           throw std::out_of_range("count");
 783         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 784           throw std::invalid_argument("invalid range");
 785         self->erase(self->begin()+index, self->begin()+index+count);
 786       }
 787 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 788         if (count < 0)
 789           throw std::out_of_range("count");
 790         return new std::vector< Dali::TouchPoint >(count, value);
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 793         std::reverse(self->begin(), self->end());
 794       }
 795 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 796         if (index < 0)
 797           throw std::out_of_range("index");
 798         if (count < 0)
 799           throw std::out_of_range("count");
 800         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 801           throw std::invalid_argument("invalid range");
 802         std::reverse(self->begin()+index, self->begin()+index+count);
 803       }
 804 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 805         if (index < 0)
 806           throw std::out_of_range("index");
 807         if (index+values.size() > self->size())
 808           throw std::out_of_range("index");
 809         std::copy(values.begin(), values.end(), self->begin()+index);
 810       }
 811 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 812          return self->Empty();
 813       }
 814 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 815         return self->GetConnectionCount();
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Connect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 821           self->Disconnect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 824           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 825 /*@SWIG@*/ self->Emit( arg );
 826       }
 827 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828          return self->Empty();
 829       }
 830 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 831         return self->GetConnectionCount();
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Connect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 837           self->Disconnect( func );
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 840           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 841 /*@SWIG@*/ self->Emit( arg );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 844          return self->Empty();
 845       }
 846 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::RefObject const *) > const *self){
 847         return self->GetConnectionCount();
 848       }
 849 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 850           self->Connect( func );
 851       }
 852 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(Dali::Signal< void (Dali::RefObject const *) > *self,void (*func)(Dali::RefObject const *)){
 853           self->Disconnect( func );
 854       }
 855 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(Dali::Signal< void (Dali::RefObject const *) > *self,Dali::RefObject const *arg){
 856           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 857 /*@SWIG@*/ self->Emit( arg );
 858       }
 859 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860          return self->Empty();
 861       }
 862 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 863         return self->GetConnectionCount();
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Connect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 869           self->Disconnect( func );
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 872           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 873 /*@SWIG@*/ self->Emit( arg );
 874       }
 875 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > const *self){
 876          return self->Empty();
 877       }
 878 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){
 879         return self->GetConnectionCount();
 880       }
 881 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 &)){
 882         self->Connect( func );
 883       }
 884 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 &)){
 885         self->Disconnect( func );
 886       }
 887 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){
 888         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 889 /*@SWIG@*/ self->Emit( arg1, arg2 );
 890       }
 891 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){
 892          return self->Empty();
 893       }
 894 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){
 895         return self->GetConnectionCount();
 896       }
 897 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 &)){
 898         self->Connect( func );
 899       }
 900 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 &)){
 901         self->Disconnect( func );
 902       }
 903 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){
 904         return self->Emit( arg1, arg2 );
 905       }
 906 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){
 907          return self->Empty();
 908       }
 909 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){
 910         return self->GetConnectionCount();
 911       }
 912 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 &)){
 913         self->Connect( func );
 914       }
 915 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 &)){
 916         self->Disconnect( func );
 917       }
 918 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){
 919         return self->Emit( arg1, arg2 );
 920       }
 921 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){
 922          return self->Empty();
 923       }
 924 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){
 925         return self->GetConnectionCount();
 926       }
 927 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 &)){
 928         self->Connect( func );
 929       }
 930 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 &)){
 931         self->Disconnect( func );
 932       }
 933 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){
 934         return self->Emit( arg1, arg2 );
 935       }
 936 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 937          return self->Empty();
 938       }
 939 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 940         return self->GetConnectionCount();
 941       }
 942 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 943           self->Connect( func );
 944       }
 945 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 946           self->Disconnect( func );
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 949           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 950 /*@SWIG@*/ self->Emit( arg );
 951       }
 952 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 953          return self->Empty();
 954       }
 955 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){
 956         return self->GetConnectionCount();
 957       }
 958 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 &)){
 959           self->Connect( func );
 960       }
 961 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 &)){
 962           self->Disconnect( func );
 963       }
 964 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){
 965           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 966 /*@SWIG@*/ self->Emit( arg );
 967       }
 968 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 969          return self->Empty();
 970       }
 971 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){
 972         return self->GetConnectionCount();
 973       }
 974 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 &)){
 975           self->Connect( func );
 976       }
 977 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 &)){
 978           self->Disconnect( func );
 979       }
 980 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){
 981           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 982 /*@SWIG@*/ self->Emit( arg );
 983       }
 984 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 985          return self->Empty();
 986       }
 987 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){
 988         return self->GetConnectionCount();
 989       }
 990 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 &)){
 991           self->Connect( func );
 992       }
 993 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 &)){
 994           self->Disconnect( func );
 995       }
 996 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){
 997           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 998 /*@SWIG@*/ self->Emit( arg );
 999       }
1000 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){
1001          return self->Empty();
1002       }
1003 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){
1004         return self->GetConnectionCount();
1005       }
1006 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 &)){
1007         self->Connect( func );
1008       }
1009 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 &)){
1010         self->Disconnect( func );
1011       }
1012 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){
1013         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1014 /*@SWIG@*/ self->Emit( arg1, arg2 );
1015       }
1016 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){
1017          return self->Empty();
1018       }
1019 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){
1020         return self->GetConnectionCount();
1021       }
1022 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 &)){
1023         self->Connect( func );
1024       }
1025 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 &)){
1026         self->Disconnect( func );
1027       }
1028 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){
1029         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1030 /*@SWIG@*/ self->Emit( arg1, arg2 );
1031       }
1032 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > const *self){
1033          return self->Empty();
1034       }
1035 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){
1036         return self->GetConnectionCount();
1037       }
1038 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 &)){
1039         self->Connect( func );
1040       }
1041 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 &)){
1042         self->Disconnect( func );
1043       }
1044 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){
1045         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1046 /*@SWIG@*/ self->Emit( arg1, arg2 );
1047       }
1048 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1049          return self->Empty();
1050       }
1051 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1052         return self->GetConnectionCount();
1053       }
1054 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1055           self->Connect( func );
1056       }
1057 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1058           self->Disconnect( func );
1059       }
1060 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1061           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1062 /*@SWIG@*/ self->Emit( arg );
1063       }
1064 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){
1065          return self->Empty();
1066       }
1067 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){
1068         return self->GetConnectionCount();
1069       }
1070 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)){
1071           return self->Connect( func );
1072       }
1073 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)){
1074           self->Disconnect( func );
1075       }
1076 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){
1077           self->Emit( arg1, arg3 );
1078       }
1079 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){
1080          return self->Empty();
1081       }
1082 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){
1083         return self->GetConnectionCount();
1084       }
1085 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)){
1086           return self->Connect( func );
1087       }
1088 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)){
1089           self->Disconnect( func );
1090       }
1091 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){
1092           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1093 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1094       }
1095
1096 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1097          return self->Empty();
1098       }
1099 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1100         return self->GetConnectionCount();
1101       }
1102 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1103           self->Connect( func );
1104       }
1105 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1106           self->Disconnect( func );
1107       }
1108 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1109           return self->Emit();
1110       }
1111
1112 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1113         std::vector< unsigned int >* pv = 0;
1114         if (capacity >= 0) {
1115           pv = new std::vector< unsigned int >();
1116           pv->reserve(capacity);
1117        } else {
1118           throw std::out_of_range("capacity");
1119        }
1120        return pv;
1121       }
1122 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1123         if (index>=0 && index<(int)self->size())
1124           return (*self)[index];
1125         else
1126           throw std::out_of_range("index");
1127       }
1128 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1129         if (index>=0 && index<(int)self->size())
1130           return (*self)[index];
1131         else
1132           throw std::out_of_range("index");
1133       }
1134 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1135         if (index>=0 && index<(int)self->size())
1136           (*self)[index] = val;
1137         else
1138           throw std::out_of_range("index");
1139       }
1140 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1141         self->insert(self->end(), values.begin(), values.end());
1142       }
1143 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1144         if (index < 0)
1145           throw std::out_of_range("index");
1146         if (count < 0)
1147           throw std::out_of_range("count");
1148         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1149           throw std::invalid_argument("invalid range");
1150         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1151       }
1152 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1153         if (index>=0 && index<(int)self->size()+1)
1154           self->insert(self->begin()+index, x);
1155         else
1156           throw std::out_of_range("index");
1157       }
1158 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1159         if (index>=0 && index<(int)self->size()+1)
1160           self->insert(self->begin()+index, values.begin(), values.end());
1161         else
1162           throw std::out_of_range("index");
1163       }
1164 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1165         if (index>=0 && index<(int)self->size())
1166           self->erase(self->begin() + index);
1167         else
1168           throw std::out_of_range("index");
1169       }
1170 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1171         if (index < 0)
1172           throw std::out_of_range("index");
1173         if (count < 0)
1174           throw std::out_of_range("count");
1175         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1176           throw std::invalid_argument("invalid range");
1177         self->erase(self->begin()+index, self->begin()+index+count);
1178       }
1179 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1180         if (count < 0)
1181           throw std::out_of_range("count");
1182         return new std::vector< unsigned int >(count, value);
1183       }
1184 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1185         std::reverse(self->begin(), self->end());
1186       }
1187 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1188         if (index < 0)
1189           throw std::out_of_range("index");
1190         if (count < 0)
1191           throw std::out_of_range("count");
1192         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1193           throw std::invalid_argument("invalid range");
1194         std::reverse(self->begin()+index, self->begin()+index+count);
1195       }
1196 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1197         if (index < 0)
1198           throw std::out_of_range("index");
1199         if (index+values.size() > self->size())
1200           throw std::out_of_range("index");
1201         std::copy(values.begin(), values.end(), self->begin()+index);
1202       }
1203 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1204         return std::find(self->begin(), self->end(), value) != self->end();
1205       }
1206 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1207         int index = -1;
1208         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1209         if (it != self->end())
1210           index = (int)(it - self->begin());
1211         return index;
1212       }
1213 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1214         int index = -1;
1215         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1216         if (rit != self->rend())
1217           index = (int)(self->rend() - 1 - rit);
1218         return index;
1219       }
1220 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1221         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1222         if (it != self->end()) {
1223           self->erase(it);
1224           return true;
1225         }
1226         return false;
1227       }
1228 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){
1229         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1230         if (capacity >= 0) {
1231           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1232           pv->reserve(capacity);
1233        } else {
1234           throw std::out_of_range("capacity");
1235        }
1236        return pv;
1237       }
1238 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){
1239         if (index>=0 && index<(int)self->size())
1240           return (*self)[index];
1241         else
1242           throw std::out_of_range("index");
1243       }
1244 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){
1245         if (index>=0 && index<(int)self->size())
1246           return (*self)[index];
1247         else
1248           throw std::out_of_range("index");
1249       }
1250 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){
1251         if (index>=0 && index<(int)self->size())
1252           (*self)[index] = val;
1253         else
1254           throw std::out_of_range("index");
1255       }
1256 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){
1257         self->insert(self->end(), values.begin(), values.end());
1258       }
1259 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){
1260         if (index < 0)
1261           throw std::out_of_range("index");
1262         if (count < 0)
1263           throw std::out_of_range("count");
1264         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1265           throw std::invalid_argument("invalid range");
1266         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1267       }
1268 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){
1269         if (index>=0 && index<(int)self->size()+1)
1270           self->insert(self->begin()+index, x);
1271         else
1272           throw std::out_of_range("index");
1273       }
1274 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){
1275         if (index>=0 && index<(int)self->size()+1)
1276           self->insert(self->begin()+index, values.begin(), values.end());
1277         else
1278           throw std::out_of_range("index");
1279       }
1280 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){
1281         if (index>=0 && index<(int)self->size())
1282           self->erase(self->begin() + index);
1283         else
1284           throw std::out_of_range("index");
1285       }
1286 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){
1287         if (index < 0)
1288           throw std::out_of_range("index");
1289         if (count < 0)
1290           throw std::out_of_range("count");
1291         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1292           throw std::invalid_argument("invalid range");
1293         self->erase(self->begin()+index, self->begin()+index+count);
1294       }
1295 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){
1296         if (count < 0)
1297           throw std::out_of_range("count");
1298         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1299       }
1300 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){
1301         std::reverse(self->begin(), self->end());
1302       }
1303 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){
1304         if (index < 0)
1305           throw std::out_of_range("index");
1306         if (count < 0)
1307           throw std::out_of_range("count");
1308         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1309           throw std::invalid_argument("invalid range");
1310         std::reverse(self->begin()+index, self->begin()+index+count);
1311       }
1312 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){
1313         if (index < 0)
1314           throw std::out_of_range("index");
1315         if (index+values.size() > self->size())
1316           throw std::out_of_range("index");
1317         std::copy(values.begin(), values.end(), self->begin()+index);
1318       }
1319 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1320         std::vector< Dali::Actor >* pv = 0;
1321         if (capacity >= 0) {
1322           pv = new std::vector< Dali::Actor >();
1323           pv->reserve(capacity);
1324        } else {
1325           throw std::out_of_range("capacity");
1326        }
1327        return pv;
1328       }
1329 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1330         if (index>=0 && index<(int)self->size())
1331           return (*self)[index];
1332         else
1333           throw std::out_of_range("index");
1334       }
1335 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1336         if (index>=0 && index<(int)self->size())
1337           return (*self)[index];
1338         else
1339           throw std::out_of_range("index");
1340       }
1341 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1342         if (index>=0 && index<(int)self->size())
1343           (*self)[index] = val;
1344         else
1345           throw std::out_of_range("index");
1346       }
1347 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1348         self->insert(self->end(), values.begin(), values.end());
1349       }
1350 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1351         if (index < 0)
1352           throw std::out_of_range("index");
1353         if (count < 0)
1354           throw std::out_of_range("count");
1355         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1356           throw std::invalid_argument("invalid range");
1357         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1358       }
1359 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1360         if (index>=0 && index<(int)self->size()+1)
1361           self->insert(self->begin()+index, x);
1362         else
1363           throw std::out_of_range("index");
1364       }
1365 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1366         if (index>=0 && index<(int)self->size()+1)
1367           self->insert(self->begin()+index, values.begin(), values.end());
1368         else
1369           throw std::out_of_range("index");
1370       }
1371 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1372         if (index>=0 && index<(int)self->size())
1373           self->erase(self->begin() + index);
1374         else
1375           throw std::out_of_range("index");
1376       }
1377 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1378         if (index < 0)
1379           throw std::out_of_range("index");
1380         if (count < 0)
1381           throw std::out_of_range("count");
1382         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1383           throw std::invalid_argument("invalid range");
1384         self->erase(self->begin()+index, self->begin()+index+count);
1385       }
1386 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1387         if (count < 0)
1388           throw std::out_of_range("count");
1389         return new std::vector< Dali::Actor >(count, value);
1390       }
1391 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1392         std::reverse(self->begin(), self->end());
1393       }
1394 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1395         if (index < 0)
1396           throw std::out_of_range("index");
1397         if (count < 0)
1398           throw std::out_of_range("count");
1399         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1400           throw std::invalid_argument("invalid range");
1401         std::reverse(self->begin()+index, self->begin()+index+count);
1402       }
1403 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1404         if (index < 0)
1405           throw std::out_of_range("index");
1406         if (index+values.size() > self->size())
1407           throw std::out_of_range("index");
1408         std::copy(values.begin(), values.end(), self->begin()+index);
1409       }
1410 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1411          return self->Empty();
1412       }
1413 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1414         return self->GetConnectionCount();
1415       }
1416 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 &)){
1417           self->Connect( func );
1418       }
1419 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 &)){
1420           self->Disconnect( func );
1421       }
1422 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){
1423           return self->Emit( arg );
1424       }
1425 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){
1426          return self->Empty();
1427       }
1428 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){
1429         return self->GetConnectionCount();
1430       }
1431 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)){
1432         self->Connect( func );
1433       }
1434 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)){
1435         self->Disconnect( func );
1436       }
1437 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){
1438         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1439 /*@SWIG@*/ self->Emit( arg1, arg2 );
1440       }
1441 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1442          return self->Empty();
1443       }
1444 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){
1445         return self->GetConnectionCount();
1446       }
1447 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)){
1448         self->Connect( func );
1449       }
1450 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)){
1451         self->Disconnect( func );
1452       }
1453 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){
1454         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1455 /*@SWIG@*/ self->Emit( arg1, arg2 );
1456       }
1457 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1458          return self->Empty();
1459       }
1460 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1461         return self->GetConnectionCount();
1462       }
1463 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)){
1464         self->Connect( func );
1465       }
1466 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)){
1467         self->Disconnect( func );
1468       }
1469 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){
1470         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg1, arg2 );
1472       }
1473 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1474          return self->Empty();
1475       }
1476 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){
1477         return self->GetConnectionCount();
1478       }
1479 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)){
1480         self->Connect( func );
1481       }
1482 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)){
1483         self->Disconnect( func );
1484       }
1485 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){
1486         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1487 /*@SWIG@*/ self->Emit( arg1, arg2 );
1488       }
1489 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1490          return self->Empty();
1491       }
1492 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1493         return self->GetConnectionCount();
1494       }
1495 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)){
1496           self->Connect( func );
1497       }
1498 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)){
1499           self->Disconnect( func );
1500       }
1501 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1502           return self->Emit( arg );
1503       }
1504 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1505          return self->Empty();
1506       }
1507 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1508         return self->GetConnectionCount();
1509       }
1510 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)){
1511           self->Connect( func );
1512       }
1513 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)){
1514           self->Disconnect( func );
1515       }
1516 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1517           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1518 /*@SWIG@*/ self->Emit( arg );
1519       }
1520 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){
1521          return self->Empty();
1522       }
1523 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){
1524         return self->GetConnectionCount();
1525       }
1526 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)){
1527           return self->Connect( func );
1528       }
1529 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)){
1530           self->Disconnect( func );
1531       }
1532 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){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1535       }
1536 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1537          return self->Empty();
1538       }
1539 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1540         return self->GetConnectionCount();
1541       }
1542 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)){
1543           self->Connect( func );
1544       }
1545 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)){
1546           self->Disconnect( func );
1547       }
1548 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1549           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1550 /*@SWIG@*/ self->Emit( arg );
1551       }
1552 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){
1553          return self->Empty();
1554       }
1555 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){
1556         return self->GetConnectionCount();
1557       }
1558 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)){
1559           return self->Connect( func );
1560       }
1561 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)){
1562           self->Disconnect( func );
1563       }
1564 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){
1565           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1566 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1567       }
1568 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){
1569          return self->Empty();
1570       }
1571 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){
1572         return self->GetConnectionCount();
1573       }
1574 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 &)){
1575           self->Connect( func );
1576       }
1577 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 &)){
1578           self->Disconnect( func );
1579       }
1580 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){
1581           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1582 /*@SWIG@*/ self->Emit( arg );
1583       }
1584 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1585          return self->Empty();
1586       }
1587 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){
1588         return self->GetConnectionCount();
1589       }
1590 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 &)){
1591           self->Connect( func );
1592       }
1593 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 &)){
1594           self->Disconnect( func );
1595       }
1596 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){
1597           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1598 /*@SWIG@*/ self->Emit( arg );
1599       }
1600
1601
1602 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){
1603          return self->Empty();
1604       }
1605 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){
1606         return self->GetConnectionCount();
1607       }
1608 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 &)){
1609         self->Connect( func );
1610       }
1611 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 &)){
1612         self->Disconnect( func );
1613       }
1614 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){
1615         return self->Emit( arg1, arg2 );
1616       }
1617 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1618          return self->Empty();
1619       }
1620 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1621         return self->GetConnectionCount();
1622       }
1623 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)){
1624           self->Connect( func );
1625       }
1626 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)){
1627           self->Disconnect( func );
1628       }
1629 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1630           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1631 /*@SWIG@*/ self->Emit( arg );
1632       }
1633 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1634          return self->Empty();
1635       }
1636 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1637         return self->GetConnectionCount();
1638       }
1639 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 &)){
1640           self->Connect( func );
1641       }
1642 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 &)){
1643           self->Disconnect( func );
1644       }
1645 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){
1646           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1647 /*@SWIG@*/ self->Emit( arg );
1648       }
1649 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1650          return self->Empty();
1651       }
1652 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){
1653         return self->GetConnectionCount();
1654       }
1655 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)){
1656         self->Connect( func );
1657       }
1658 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)){
1659         self->Disconnect( func );
1660       }
1661 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){
1662         return self->Emit( arg1, arg2 );
1663       }
1664 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1665          return self->Empty();
1666       }
1667 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){
1668         return self->GetConnectionCount();
1669       }
1670 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)){
1671         self->Connect( func );
1672       }
1673 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)){
1674         self->Disconnect( func );
1675       }
1676 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){
1677         return self->Emit( arg1, arg2 );
1678       }
1679
1680 /* ---------------------------------------------------
1681  * C++ director class methods
1682  * --------------------------------------------------- */
1683
1684 #include "dali_wrap.h"
1685
1686 /*
1687  *  Widget director
1688  */
1689 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1690   swig_init_callbacks();
1691 }
1692
1693 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1694 }
1695
1696 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1697   char * jcontentInfo = 0 ;
1698   void * jwindow  ;
1699
1700   if (!swig_callbackOnCreate) {
1701     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1702     return;
1703   } else {
1704     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1705     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1706     swig_callbackOnCreate(jcontentInfo, jwindow);
1707   }
1708 }
1709
1710 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1711   char * jcontentInfo = 0 ;
1712   int jtype  ;
1713
1714   if (!swig_callbackOnTerminate) {
1715     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1716     return;
1717   } else {
1718     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1719     jtype = (int)type;
1720     swig_callbackOnTerminate(jcontentInfo, jtype);
1721   }
1722 }
1723
1724 void SwigDirector_WidgetImpl::OnPause() {
1725   if (!swig_callbackOnPause) {
1726     Dali::Internal::Adaptor::Widget::OnPause();
1727     return;
1728   } else {
1729     swig_callbackOnPause();
1730   }
1731 }
1732
1733 void SwigDirector_WidgetImpl::OnResume() {
1734   if (!swig_callbackOnResume) {
1735     Dali::Internal::Adaptor::Widget::OnResume();
1736     return;
1737   } else {
1738     swig_callbackOnResume();
1739   }
1740 }
1741
1742 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1743   void * jwindow  ;
1744
1745   if (!swig_callbackOnResize) {
1746     Dali::Internal::Adaptor::Widget::OnResize(window);
1747     return;
1748   } else {
1749     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1750     swig_callbackOnResize(jwindow);
1751   }
1752 }
1753
1754 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1755   char * jcontentInfo = 0 ;
1756   int jforce  ;
1757
1758   if (!swig_callbackOnUpdate) {
1759     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1760     return;
1761   } else {
1762     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1763     jforce = force;
1764     swig_callbackOnUpdate(jcontentInfo, jforce);
1765   }
1766 }
1767
1768 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1769   void * jslotObserver = 0 ;
1770   void * jcallback = 0 ;
1771
1772   if (!swig_callbackSignalConnected) {
1773     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1774     return;
1775   } else {
1776     jslotObserver = (void *) slotObserver;
1777     jcallback = (void *) callback;
1778     swig_callbackSignalConnected(jslotObserver, jcallback);
1779   }
1780 }
1781
1782 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1783   void * jslotObserver = 0 ;
1784   void * jcallback = 0 ;
1785
1786   if (!swig_callbackSignalDisconnected) {
1787     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1788     return;
1789   } else {
1790     jslotObserver = (void *) slotObserver;
1791     jcallback = (void *) callback;
1792     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1793   }
1794 }
1795
1796 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) {
1797
1798   swig_callbackOnCreate = callbackOnCreate;
1799   swig_callbackOnTerminate = callbackOnTerminate;
1800   swig_callbackOnPause = callbackOnPause;
1801   swig_callbackOnResume = callbackOnResume;
1802   swig_callbackOnResize = callbackOnResize;
1803   swig_callbackOnUpdate = callbackOnUpdate;
1804   swig_callbackSignalConnected = callbackSignalConnected;
1805   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1806 }
1807
1808 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1809   swig_callbackOnCreate = 0;
1810   swig_callbackOnTerminate = 0;
1811   swig_callbackOnPause = 0;
1812   swig_callbackOnResume = 0;
1813   swig_callbackOnResize = 0;
1814   swig_callbackOnUpdate = 0;
1815   swig_callbackSignalConnected = 0;
1816   swig_callbackSignalDisconnected = 0;
1817 }
1818
1819
1820 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1821   swig_init_callbacks();
1822 }
1823
1824 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1825
1826 }
1827
1828
1829 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1830   int jdepth  ;
1831
1832   if (!swig_callbackOnStageConnection) {
1833     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1834     return;
1835   } else {
1836     jdepth = depth;
1837     swig_callbackOnStageConnection(jdepth);
1838   }
1839 }
1840
1841 void SwigDirector_ViewImpl::OnStageDisconnection() {
1842   if (!swig_callbackOnStageDisconnection) {
1843     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1844     return;
1845   } else {
1846     swig_callbackOnStageDisconnection();
1847   }
1848 }
1849
1850 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1851   void * jchild = 0 ;
1852
1853   if (!swig_callbackOnChildAdd) {
1854     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1855     return;
1856   } else {
1857     jchild = (Dali::Actor *) &child;
1858     swig_callbackOnChildAdd(jchild);
1859   }
1860 }
1861
1862 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1863   void * jchild = 0 ;
1864
1865   if (!swig_callbackOnChildRemove) {
1866     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1867     return;
1868   } else {
1869     jchild = (Dali::Actor *) &child;
1870     swig_callbackOnChildRemove(jchild);
1871   }
1872 }
1873
1874 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1875   int jindex  ;
1876   void * jpropertyValue  ;
1877
1878   if (!swig_callbackOnPropertySet) {
1879     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1880     return;
1881   } else {
1882     jindex = index;
1883     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1884     swig_callbackOnPropertySet(jindex, jpropertyValue);
1885   }
1886 }
1887
1888 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1889   void * jtargetSize = 0 ;
1890
1891   if (!swig_callbackOnSizeSet) {
1892     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1893     return;
1894   } else {
1895     jtargetSize = (Dali::Vector3 *) &targetSize;
1896     swig_callbackOnSizeSet(jtargetSize);
1897   }
1898 }
1899
1900 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1901   void * janimation = 0 ;
1902   void * jtargetSize = 0 ;
1903
1904   if (!swig_callbackOnSizeAnimation) {
1905     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1906     return;
1907   } else {
1908     janimation = (Dali::Animation *) &animation;
1909     jtargetSize = (Dali::Vector3 *) &targetSize;
1910     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1911   }
1912 }
1913
1914 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1915   bool c_result = SwigValueInit< bool >() ;
1916   unsigned int jresult = 0 ;
1917   void * jarg0 = 0 ;
1918
1919   if (!swig_callbackOnTouchEvent) {
1920     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1921   } else {
1922     jarg0 = (Dali::TouchEvent *) &event;
1923     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1924     c_result = jresult ? true : false;
1925   }
1926   return c_result;
1927 }
1928
1929 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1930   bool c_result = SwigValueInit< bool >() ;
1931   unsigned int jresult = 0 ;
1932   void * jarg0 = 0 ;
1933
1934   if (!swig_callbackOnHoverEvent) {
1935     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1936   } else {
1937     jarg0 = (Dali::HoverEvent *) &event;
1938     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1939     c_result = jresult ? true : false;
1940   }
1941   return c_result;
1942 }
1943
1944 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1945   bool c_result = SwigValueInit< bool >() ;
1946   unsigned int jresult = 0 ;
1947   void * jarg0 = 0 ;
1948
1949   if (!swig_callbackOnKeyEvent) {
1950     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1951   } else {
1952     jarg0 = (Dali::KeyEvent *) &event;
1953     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1954     c_result = jresult ? true : false;
1955   }
1956   return c_result;
1957 }
1958
1959 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1960   bool c_result = SwigValueInit< bool >() ;
1961   unsigned int jresult = 0 ;
1962   void * jarg0 = 0 ;
1963
1964   if (!swig_callbackOnWheelEvent) {
1965     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1966   } else {
1967     jarg0 = (Dali::WheelEvent *) &event;
1968     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1969     c_result = jresult ? true : false;
1970   }
1971   return c_result;
1972 }
1973
1974 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1975   void * jsize = 0 ;
1976   void * jcontainer = 0 ;
1977
1978   if (!swig_callbackOnRelayout) {
1979     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1980     return;
1981   } else {
1982     jsize = (Dali::Vector2 *) &size;
1983     jcontainer = (Dali::RelayoutContainer *) &container;
1984     swig_callbackOnRelayout(jsize, jcontainer);
1985   }
1986 }
1987
1988 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1989   int jpolicy  ;
1990   int jdimension  ;
1991
1992   if (!swig_callbackOnSetResizePolicy) {
1993     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1994     return;
1995   } else {
1996     jpolicy = (int)policy;
1997     jdimension = (int)dimension;
1998     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1999   }
2000 }
2001
2002 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2003   Dali::Vector3 c_result ;
2004   void * jresult = 0 ;
2005
2006   if (!swig_callbackGetNaturalSize) {
2007     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2008   } else {
2009     jresult = (void *) swig_callbackGetNaturalSize();
2010     if (!jresult) {
2011       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2012       return c_result;
2013     }
2014     c_result = *(Dali::Vector3 *)jresult;
2015   }
2016   return c_result;
2017 }
2018
2019 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2020   float c_result = SwigValueInit< float >() ;
2021   float jresult = 0 ;
2022   void * jchild = 0 ;
2023   int jdimension  ;
2024
2025   if (!swig_callbackCalculateChildSize) {
2026     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2027   } else {
2028     jchild = (Dali::Actor *) &child;
2029     jdimension = (int)dimension;
2030     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2031     c_result = (float)jresult;
2032   }
2033   return c_result;
2034 }
2035
2036 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2037   float c_result = SwigValueInit< float >() ;
2038   float jresult = 0 ;
2039   float jwidth  ;
2040
2041   if (!swig_callbackGetHeightForWidth) {
2042     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2043   } else {
2044     jwidth = width;
2045     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2046     c_result = (float)jresult;
2047   }
2048   return c_result;
2049 }
2050
2051 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2052   float c_result = SwigValueInit< float >() ;
2053   float jresult = 0 ;
2054   float jheight  ;
2055
2056   if (!swig_callbackGetWidthForHeight) {
2057     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2058   } else {
2059     jheight = height;
2060     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2061     c_result = (float)jresult;
2062   }
2063   return c_result;
2064 }
2065
2066 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2067   bool c_result = SwigValueInit< bool >() ;
2068   unsigned int jresult = 0 ;
2069   int jdimension  ;
2070
2071   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2072     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2073   } else {
2074     jdimension = (int)dimension;
2075     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2076     c_result = jresult ? true : false;
2077   }
2078   return c_result;
2079 }
2080
2081 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2082   int jdimension  ;
2083
2084   if (!swig_callbackOnCalculateRelayoutSize) {
2085     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2086     return;
2087   } else {
2088     jdimension = (int)dimension;
2089     swig_callbackOnCalculateRelayoutSize(jdimension);
2090   }
2091 }
2092
2093 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2094   float jsize  ;
2095   int jdimension  ;
2096
2097   if (!swig_callbackOnLayoutNegotiated) {
2098     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2099     return;
2100   } else {
2101     jsize = size;
2102     jdimension = (int)dimension;
2103     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2104   }
2105 }
2106
2107 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2108   return Dali::CustomActorImpl::GetExtension();
2109 }
2110
2111 void SwigDirector_ViewImpl::OnInitialize() {
2112   if (!swig_callbackOnInitialize) {
2113     Dali::Toolkit::Internal::Control::OnInitialize();
2114     return;
2115   } else {
2116     swig_callbackOnInitialize();
2117   }
2118 }
2119
2120 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2121   void * jchild = 0 ;
2122
2123   if (!swig_callbackOnControlChildAdd) {
2124     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2125     return;
2126   } else {
2127     jchild = (Dali::Actor *) &child;
2128     swig_callbackOnControlChildAdd(jchild);
2129   }
2130 }
2131
2132 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2133   void * jchild = 0 ;
2134
2135   if (!swig_callbackOnControlChildRemove) {
2136     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2137     return;
2138   } else {
2139     jchild = (Dali::Actor *) &child;
2140     swig_callbackOnControlChildRemove(jchild);
2141   }
2142 }
2143
2144 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2145   void * jstyleManager  ;
2146   int jchange  ;
2147
2148   if (!swig_callbackOnStyleChange) {
2149     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2150     return;
2151   } else {
2152     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2153     jchange = (int)change;
2154     swig_callbackOnStyleChange(jstyleManager, jchange);
2155   }
2156 }
2157
2158 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2159   bool c_result = SwigValueInit< bool >() ;
2160   unsigned int jresult = 0 ;
2161
2162   if (!swig_callbackOnAccessibilityActivated) {
2163     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2164   } else {
2165     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2166     c_result = jresult ? true : false;
2167   }
2168   return c_result;
2169 }
2170
2171 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2172   bool c_result = SwigValueInit< bool >() ;
2173   unsigned int jresult = 0 ;
2174   void * jgesture  ;
2175
2176   if (!swig_callbackOnAccessibilityPan) {
2177     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2178   } else {
2179     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2180     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2181     c_result = jresult ? true : false;
2182   }
2183   return c_result;
2184 }
2185
2186 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2187   bool c_result = SwigValueInit< bool >() ;
2188   unsigned int jresult = 0 ;
2189   void * jtouchEvent = 0 ;
2190
2191   if (!swig_callbackOnAccessibilityTouch) {
2192     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2193   } else {
2194     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2195     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2196     c_result = jresult ? true : false;
2197   }
2198   return c_result;
2199 }
2200
2201 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2202   bool c_result = SwigValueInit< bool >() ;
2203   unsigned int jresult = 0 ;
2204   unsigned int jisIncrease  ;
2205
2206   if (!swig_callbackOnAccessibilityValueChange) {
2207     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2208   } else {
2209     jisIncrease = isIncrease;
2210     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2211     c_result = jresult ? true : false;
2212   }
2213   return c_result;
2214 }
2215
2216 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2217   bool c_result = SwigValueInit< bool >() ;
2218   unsigned int jresult = 0 ;
2219
2220   if (!swig_callbackOnAccessibilityZoom) {
2221     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2222   } else {
2223     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2224     c_result = jresult ? true : false;
2225   }
2226   return c_result;
2227 }
2228
2229 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2230   if (!swig_callbackOnKeyInputFocusGained) {
2231     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2232     return;
2233   } else {
2234     swig_callbackOnKeyInputFocusGained();
2235   }
2236 }
2237
2238 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2239   if (!swig_callbackOnKeyInputFocusLost) {
2240     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2241     return;
2242   } else {
2243     swig_callbackOnKeyInputFocusLost();
2244   }
2245 }
2246
2247 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2248   Dali::Actor c_result ;
2249   void * jresult = 0 ;
2250   void * jcurrentFocusedActor  ;
2251   int jdirection  ;
2252   unsigned int jloopEnabled  ;
2253
2254   if (!swig_callbackGetNextKeyboardFocusableActor) {
2255     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2256   } else {
2257     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2258     jdirection = (int)direction;
2259     jloopEnabled = loopEnabled;
2260     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2261     if (!jresult) {
2262       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2263       return c_result;
2264     }
2265     c_result = *(Dali::Actor *)jresult;
2266   }
2267   return c_result;
2268 }
2269
2270 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2271   void * jcommitedFocusableActor  ;
2272
2273   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2274     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2275     return;
2276   } else {
2277     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2278     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2279   }
2280 }
2281
2282 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2283   bool c_result = SwigValueInit< bool >() ;
2284   unsigned int jresult = 0 ;
2285
2286   if (!swig_callbackOnKeyboardEnter) {
2287     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2288   } else {
2289     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2290     c_result = jresult ? true : false;
2291   }
2292   return c_result;
2293 }
2294
2295 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2296   void * jpinch = 0 ;
2297
2298   if (!swig_callbackOnPinch) {
2299     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2300     return;
2301   } else {
2302     jpinch = (Dali::PinchGesture *) &pinch;
2303     swig_callbackOnPinch(jpinch);
2304   }
2305 }
2306
2307 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2308   void * jpan = 0 ;
2309
2310   if (!swig_callbackOnPan) {
2311     Dali::Toolkit::Internal::Control::OnPan(pan);
2312     return;
2313   } else {
2314     jpan = (Dali::PanGesture *) &pan;
2315     swig_callbackOnPan(jpan);
2316   }
2317 }
2318
2319 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2320   void * jtap = 0 ;
2321
2322   if (!swig_callbackOnTap) {
2323     Dali::Toolkit::Internal::Control::OnTap(tap);
2324     return;
2325   } else {
2326     jtap = (Dali::TapGesture *) &tap;
2327     swig_callbackOnTap(jtap);
2328   }
2329 }
2330
2331 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2332   void * jlongPress = 0 ;
2333
2334   if (!swig_callbackOnLongPress) {
2335     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2336     return;
2337   } else {
2338     jlongPress = (Dali::LongPressGesture *) &longPress;
2339     swig_callbackOnLongPress(jlongPress);
2340   }
2341 }
2342
2343 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2344   void * jslotObserver = 0 ;
2345   void * jcallback = 0 ;
2346
2347   if (!swig_callbackSignalConnected) {
2348     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2349     return;
2350   } else {
2351     jslotObserver = (void *) slotObserver;
2352     jcallback = (void *) callback;
2353     swig_callbackSignalConnected(jslotObserver, jcallback);
2354   }
2355 }
2356
2357 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2358   void * jslotObserver = 0 ;
2359   void * jcallback = 0 ;
2360
2361   if (!swig_callbackSignalDisconnected) {
2362     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2363     return;
2364   } else {
2365     jslotObserver = (void *) slotObserver;
2366     jcallback = (void *) callback;
2367     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2368   }
2369 }
2370
2371 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2372   return Dali::Toolkit::Internal::Control::GetControlExtension();
2373 }
2374
2375 void SwigDirector_ViewImpl::swig_connect_director(SWIG_Callback0_t callbackOnStageConnection, SWIG_Callback1_t callbackOnStageDisconnection, SWIG_Callback2_t callbackOnChildAdd, SWIG_Callback3_t callbackOnChildRemove, SWIG_Callback4_t callbackOnPropertySet, SWIG_Callback5_t callbackOnSizeSet, SWIG_Callback6_t callbackOnSizeAnimation, SWIG_Callback7_t callbackOnTouchEvent, SWIG_Callback8_t callbackOnHoverEvent, SWIG_Callback9_t callbackOnKeyEvent, SWIG_Callback10_t callbackOnWheelEvent, SWIG_Callback11_t callbackOnRelayout, SWIG_Callback12_t callbackOnSetResizePolicy, SWIG_Callback13_t callbackGetNaturalSize, SWIG_Callback14_t callbackCalculateChildSize, SWIG_Callback15_t callbackGetHeightForWidth, SWIG_Callback16_t callbackGetWidthForHeight, SWIG_Callback17_t callbackRelayoutDependentOnChildren__SWIG_0, SWIG_Callback18_t callbackRelayoutDependentOnChildren__SWIG_1, SWIG_Callback19_t callbackOnCalculateRelayoutSize, SWIG_Callback20_t callbackOnLayoutNegotiated, SWIG_Callback21_t callbackOnInitialize, SWIG_Callback22_t callbackOnControlChildAdd, SWIG_Callback23_t callbackOnControlChildRemove, SWIG_Callback24_t callbackOnStyleChange, SWIG_Callback25_t callbackOnAccessibilityActivated, SWIG_Callback26_t callbackOnAccessibilityPan, SWIG_Callback27_t callbackOnAccessibilityTouch, SWIG_Callback28_t callbackOnAccessibilityValueChange, SWIG_Callback29_t callbackOnAccessibilityZoom, SWIG_Callback30_t callbackOnKeyInputFocusGained, SWIG_Callback31_t callbackOnKeyInputFocusLost, SWIG_Callback32_t callbackGetNextKeyboardFocusableActor, SWIG_Callback33_t callbackOnKeyboardFocusChangeCommitted, SWIG_Callback34_t callbackOnKeyboardEnter, SWIG_Callback35_t callbackOnPinch, SWIG_Callback36_t callbackOnPan, SWIG_Callback37_t callbackOnTap, SWIG_Callback38_t callbackOnLongPress, SWIG_Callback39_t callbackSignalConnected, SWIG_Callback40_t callbackSignalDisconnected) {
2376   swig_callbackOnStageConnection = callbackOnStageConnection;
2377   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2378   swig_callbackOnChildAdd = callbackOnChildAdd;
2379   swig_callbackOnChildRemove = callbackOnChildRemove;
2380   swig_callbackOnPropertySet = callbackOnPropertySet;
2381   swig_callbackOnSizeSet = callbackOnSizeSet;
2382   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2383   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2384   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2385   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2386   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2387   swig_callbackOnRelayout = callbackOnRelayout;
2388   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2389   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2390   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2391   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2392   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2393   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2394   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2395   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2396   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2397   swig_callbackOnInitialize = callbackOnInitialize;
2398   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2399   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2400   swig_callbackOnStyleChange = callbackOnStyleChange;
2401   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2402   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2403   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2404   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2405   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2406   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2407   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2408   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2409   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2410   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2411   swig_callbackOnPinch = callbackOnPinch;
2412   swig_callbackOnPan = callbackOnPan;
2413   swig_callbackOnTap = callbackOnTap;
2414   swig_callbackOnLongPress = callbackOnLongPress;
2415   swig_callbackSignalConnected = callbackSignalConnected;
2416   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2417 }
2418
2419 void SwigDirector_ViewImpl::swig_init_callbacks() {
2420   swig_callbackOnStageConnection = 0;
2421   swig_callbackOnStageDisconnection = 0;
2422   swig_callbackOnChildAdd = 0;
2423   swig_callbackOnChildRemove = 0;
2424   swig_callbackOnPropertySet = 0;
2425   swig_callbackOnSizeSet = 0;
2426   swig_callbackOnSizeAnimation = 0;
2427   swig_callbackOnTouchEvent = 0;
2428   swig_callbackOnHoverEvent = 0;
2429   swig_callbackOnKeyEvent = 0;
2430   swig_callbackOnWheelEvent = 0;
2431   swig_callbackOnRelayout = 0;
2432   swig_callbackOnSetResizePolicy = 0;
2433   swig_callbackGetNaturalSize = 0;
2434   swig_callbackCalculateChildSize = 0;
2435   swig_callbackGetHeightForWidth = 0;
2436   swig_callbackGetWidthForHeight = 0;
2437   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2438   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2439   swig_callbackOnCalculateRelayoutSize = 0;
2440   swig_callbackOnLayoutNegotiated = 0;
2441   swig_callbackOnInitialize = 0;
2442   swig_callbackOnControlChildAdd = 0;
2443   swig_callbackOnControlChildRemove = 0;
2444   swig_callbackOnStyleChange = 0;
2445   swig_callbackOnAccessibilityActivated = 0;
2446   swig_callbackOnAccessibilityPan = 0;
2447   swig_callbackOnAccessibilityTouch = 0;
2448   swig_callbackOnAccessibilityValueChange = 0;
2449   swig_callbackOnAccessibilityZoom = 0;
2450   swig_callbackOnKeyInputFocusGained = 0;
2451   swig_callbackOnKeyInputFocusLost = 0;
2452   swig_callbackGetNextKeyboardFocusableActor = 0;
2453   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2454   swig_callbackOnKeyboardEnter = 0;
2455   swig_callbackOnPinch = 0;
2456   swig_callbackOnPan = 0;
2457   swig_callbackOnTap = 0;
2458   swig_callbackOnLongPress = 0;
2459   swig_callbackSignalConnected = 0;
2460   swig_callbackSignalDisconnected = 0;
2461 }
2462
2463 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2464   swig_init_callbacks();
2465 }
2466
2467 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2468
2469 }
2470
2471
2472 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2473   unsigned int c_result = SwigValueInit< unsigned int >() ;
2474   unsigned int jresult = 0 ;
2475
2476   if (!swig_callbackGetNumberOfItems) {
2477     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2478   } else {
2479     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2480     c_result = (unsigned int)jresult;
2481   }
2482   return c_result;
2483 }
2484
2485 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2486   Dali::Actor c_result ;
2487   void * jresult = 0 ;
2488   unsigned int jitemId  ;
2489
2490   if (!swig_callbackNewItem) {
2491     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2492   } else {
2493     jitemId = itemId;
2494     jresult = (void *) swig_callbackNewItem(jitemId);
2495     if (!jresult) {
2496       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2497       return c_result;
2498     }
2499     c_result = *(Dali::Actor *)jresult;
2500   }
2501   return c_result;
2502 }
2503
2504 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2505   unsigned int jitemId  ;
2506   void * jactor  ;
2507
2508   if (!swig_callbackItemReleased) {
2509     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2510     return;
2511   } else {
2512     jitemId = itemId;
2513     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2514     swig_callbackItemReleased(jitemId, jactor);
2515   }
2516 }
2517
2518 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2519   return Dali::Toolkit::ItemFactory::GetExtension();
2520 }
2521
2522 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2523   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2524   swig_callbackNewItem = callbackNewItem;
2525   swig_callbackItemReleased = callbackItemReleased;
2526 }
2527
2528 void SwigDirector_ItemFactory::swig_init_callbacks() {
2529   swig_callbackGetNumberOfItems = 0;
2530   swig_callbackNewItem = 0;
2531   swig_callbackItemReleased = 0;
2532 }
2533
2534 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2535   swig_init_callbacks();
2536 }
2537
2538 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2539
2540 }
2541
2542
2543 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2544   Dali::Actor c_result ;
2545   void * jresult = 0 ;
2546   void * jcurrent  ;
2547   void * jproposed  ;
2548   int jdirection  ;
2549
2550   if (!swig_callbackGetNextFocusableActor) {
2551     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2552   } else {
2553     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2554     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2555     jdirection = (int)direction;
2556     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2557     if (!jresult) {
2558       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__);
2559       return c_result;
2560     }
2561     c_result = *(Dali::Actor *)jresult;
2562   }
2563   return c_result;
2564 }
2565
2566 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2567   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2568 }
2569
2570 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2571   swig_callbackGetNextFocusableActor = 0;
2572 }
2573
2574
2575 #ifdef __cplusplus
2576 extern "C" {
2577 #endif
2578
2579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2580   void * jresult ;
2581   floatp *result = 0 ;
2582
2583   {
2584     try {
2585       result = (floatp *)new_floatp();
2586     } catch (std::out_of_range& e) {
2587       {
2588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2589       };
2590     } catch (std::exception& e) {
2591       {
2592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2593       };
2594     } catch (DaliException e) {
2595       {
2596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2597       };
2598     } catch (...) {
2599       {
2600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2601       };
2602     }
2603   }
2604   jresult = (void *)result;
2605   return jresult;
2606 }
2607
2608
2609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2610   floatp *arg1 = (floatp *) 0 ;
2611
2612   arg1 = (floatp *)jarg1;
2613   {
2614     try {
2615       delete_floatp(arg1);
2616     } catch (std::out_of_range& e) {
2617       {
2618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2619       };
2620     } catch (std::exception& e) {
2621       {
2622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2623       };
2624     } catch (Dali::DaliException e) {
2625       {
2626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2627       };
2628     } catch (...) {
2629       {
2630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2631       };
2632     }
2633   }
2634
2635 }
2636
2637
2638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2639   floatp *arg1 = (floatp *) 0 ;
2640   float arg2 ;
2641
2642   arg1 = (floatp *)jarg1;
2643   arg2 = (float)jarg2;
2644   {
2645     try {
2646       floatp_assign(arg1,arg2);
2647     } catch (std::out_of_range& e) {
2648       {
2649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2650       };
2651     } catch (std::exception& e) {
2652       {
2653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2654       };
2655     } catch (Dali::DaliException e) {
2656       {
2657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2658       };
2659     } catch (...) {
2660       {
2661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2662       };
2663     }
2664   }
2665
2666 }
2667
2668
2669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2670   float jresult ;
2671   floatp *arg1 = (floatp *) 0 ;
2672   float result;
2673
2674   arg1 = (floatp *)jarg1;
2675   {
2676     try {
2677       result = (float)floatp_value(arg1);
2678     } catch (std::out_of_range& e) {
2679       {
2680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2681       };
2682     } catch (std::exception& e) {
2683       {
2684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2685       };
2686     } catch (DaliException e) {
2687       {
2688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2689       };
2690     } catch (...) {
2691       {
2692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2693       };
2694     }
2695   }
2696   jresult = result;
2697   return jresult;
2698 }
2699
2700
2701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2702   void * jresult ;
2703   floatp *arg1 = (floatp *) 0 ;
2704   float *result = 0 ;
2705
2706   arg1 = (floatp *)jarg1;
2707   {
2708     try {
2709       result = (float *)floatp_cast(arg1);
2710     } catch (std::out_of_range& e) {
2711       {
2712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2713       };
2714     } catch (std::exception& e) {
2715       {
2716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2717       };
2718     } catch (Dali::DaliException e) {
2719       {
2720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2721       };
2722     } catch (...) {
2723       {
2724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2725       };
2726     }
2727   }
2728
2729   jresult = (void *)result;
2730   return jresult;
2731 }
2732
2733
2734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2735   void * jresult ;
2736   float *arg1 = (float *) 0 ;
2737   floatp *result = 0 ;
2738
2739   arg1 = (float *)jarg1;
2740   {
2741     try {
2742       result = (floatp *)floatp_frompointer(arg1);
2743     } catch (std::out_of_range& e) {
2744       {
2745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2746       };
2747     } catch (std::exception& e) {
2748       {
2749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2750       };
2751     } catch (Dali::DaliException e) {
2752       {
2753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2754       };
2755     } catch (...) {
2756       {
2757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2758       };
2759     }
2760   }
2761
2762   jresult = (void *)result;
2763   return jresult;
2764 }
2765
2766
2767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2768   void * jresult ;
2769   intp *result = 0 ;
2770
2771   {
2772     try {
2773       result = (intp *)new_intp();
2774     } catch (std::out_of_range& e) {
2775       {
2776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2777       };
2778     } catch (std::exception& e) {
2779       {
2780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2781       };
2782     } catch (Dali::DaliException e) {
2783       {
2784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2785       };
2786     } catch (...) {
2787       {
2788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2789       };
2790     }
2791   }
2792
2793   jresult = (void *)result;
2794   return jresult;
2795 }
2796
2797
2798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2799   intp *arg1 = (intp *) 0 ;
2800
2801   arg1 = (intp *)jarg1;
2802   {
2803     try {
2804       delete_intp(arg1);
2805     } catch (std::out_of_range& e) {
2806       {
2807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2808       };
2809     } catch (std::exception& e) {
2810       {
2811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2812       };
2813     } catch (Dali::DaliException e) {
2814       {
2815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2816       };
2817     } catch (...) {
2818       {
2819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2820       };
2821     }
2822   }
2823
2824 }
2825
2826
2827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2828   intp *arg1 = (intp *) 0 ;
2829   int arg2 ;
2830
2831   arg1 = (intp *)jarg1;
2832   arg2 = (int)jarg2;
2833   {
2834     try {
2835       intp_assign(arg1,arg2);
2836     } catch (std::out_of_range& e) {
2837       {
2838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2839       };
2840     } catch (std::exception& e) {
2841       {
2842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2843       };
2844     } catch (Dali::DaliException e) {
2845       {
2846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2847       };
2848     } catch (...) {
2849       {
2850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2851       };
2852     }
2853   }
2854
2855 }
2856
2857
2858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2859   int jresult ;
2860   intp *arg1 = (intp *) 0 ;
2861   int result;
2862
2863   arg1 = (intp *)jarg1;
2864   {
2865     try {
2866       result = (int)intp_value(arg1);
2867     } catch (std::out_of_range& e) {
2868       {
2869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2870       };
2871     } catch (std::exception& e) {
2872       {
2873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2874       };
2875     } catch (Dali::DaliException e) {
2876       {
2877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2878       };
2879     } catch (...) {
2880       {
2881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2882       };
2883     }
2884   }
2885
2886   jresult = result;
2887   return jresult;
2888 }
2889
2890
2891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2892   void * jresult ;
2893   intp *arg1 = (intp *) 0 ;
2894   int *result = 0 ;
2895
2896   arg1 = (intp *)jarg1;
2897   {
2898     try {
2899       result = (int *)intp_cast(arg1);
2900     } catch (std::out_of_range& e) {
2901       {
2902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2903       };
2904     } catch (std::exception& e) {
2905       {
2906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2907       };
2908     } catch (Dali::DaliException e) {
2909       {
2910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2911       };
2912     } catch (...) {
2913       {
2914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2915       };
2916     }
2917   }
2918
2919   jresult = (void *)result;
2920   return jresult;
2921 }
2922
2923
2924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2925   void * jresult ;
2926   int *arg1 = (int *) 0 ;
2927   intp *result = 0 ;
2928
2929   arg1 = (int *)jarg1;
2930   {
2931     try {
2932       result = (intp *)intp_frompointer(arg1);
2933     } catch (std::out_of_range& e) {
2934       {
2935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2936       };
2937     } catch (std::exception& e) {
2938       {
2939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2940       };
2941     } catch (Dali::DaliException e) {
2942       {
2943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2944       };
2945     } catch (...) {
2946       {
2947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2948       };
2949     }
2950   }
2951
2952   jresult = (void *)result;
2953   return jresult;
2954 }
2955
2956
2957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2958   void * jresult ;
2959   doublep *result = 0 ;
2960
2961   {
2962     try {
2963       result = (doublep *)new_doublep();
2964     } catch (std::out_of_range& e) {
2965       {
2966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2967       };
2968     } catch (std::exception& e) {
2969       {
2970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2971       };
2972     } catch (Dali::DaliException e) {
2973       {
2974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2975       };
2976     } catch (...) {
2977       {
2978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2979       };
2980     }
2981   }
2982
2983   jresult = (void *)result;
2984   return jresult;
2985 }
2986
2987
2988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2989   doublep *arg1 = (doublep *) 0 ;
2990
2991   arg1 = (doublep *)jarg1;
2992   {
2993     try {
2994       delete_doublep(arg1);
2995     } catch (std::out_of_range& e) {
2996       {
2997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2998       };
2999     } catch (std::exception& e) {
3000       {
3001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3002       };
3003     } catch (Dali::DaliException e) {
3004       {
3005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3006       };
3007     } catch (...) {
3008       {
3009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3010       };
3011     }
3012   }
3013
3014 }
3015
3016
3017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3018   doublep *arg1 = (doublep *) 0 ;
3019   double arg2 ;
3020
3021   arg1 = (doublep *)jarg1;
3022   arg2 = (double)jarg2;
3023   {
3024     try {
3025       doublep_assign(arg1,arg2);
3026     } catch (std::out_of_range& e) {
3027       {
3028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3029       };
3030     } catch (std::exception& e) {
3031       {
3032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3033       };
3034     } catch (Dali::DaliException e) {
3035       {
3036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3037       };
3038     } catch (...) {
3039       {
3040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3041       };
3042     }
3043   }
3044
3045 }
3046
3047
3048 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3049   double jresult ;
3050   doublep *arg1 = (doublep *) 0 ;
3051   double result;
3052
3053   arg1 = (doublep *)jarg1;
3054   {
3055     try {
3056       result = (double)doublep_value(arg1);
3057     } catch (std::out_of_range& e) {
3058       {
3059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3060       };
3061     } catch (std::exception& e) {
3062       {
3063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3064       };
3065     } catch (Dali::DaliException e) {
3066       {
3067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3068       };
3069     } catch (...) {
3070       {
3071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3072       };
3073     }
3074   }
3075
3076   jresult = result;
3077   return jresult;
3078 }
3079
3080
3081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3082   void * jresult ;
3083   doublep *arg1 = (doublep *) 0 ;
3084   double *result = 0 ;
3085
3086   arg1 = (doublep *)jarg1;
3087   {
3088     try {
3089       result = (double *)doublep_cast(arg1);
3090     } catch (std::out_of_range& e) {
3091       {
3092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3093       };
3094     } catch (std::exception& e) {
3095       {
3096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3097       };
3098     } catch (Dali::DaliException e) {
3099       {
3100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3101       };
3102     } catch (...) {
3103       {
3104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3105       };
3106     }
3107   }
3108
3109   jresult = (void *)result;
3110   return jresult;
3111 }
3112
3113
3114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3115   void * jresult ;
3116   double *arg1 = (double *) 0 ;
3117   doublep *result = 0 ;
3118
3119   arg1 = (double *)jarg1;
3120   {
3121     try {
3122       result = (doublep *)doublep_frompointer(arg1);
3123     } catch (std::out_of_range& e) {
3124       {
3125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3126       };
3127     } catch (std::exception& e) {
3128       {
3129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3130       };
3131     } catch (Dali::DaliException e) {
3132       {
3133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3134       };
3135     } catch (...) {
3136       {
3137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3138       };
3139     }
3140   }
3141
3142   jresult = (void *)result;
3143   return jresult;
3144 }
3145
3146
3147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3148   void * jresult ;
3149   uintp *result = 0 ;
3150
3151   {
3152     try {
3153       result = (uintp *)new_uintp();
3154     } catch (std::out_of_range& e) {
3155       {
3156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3157       };
3158     } catch (std::exception& e) {
3159       {
3160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3161       };
3162     } catch (Dali::DaliException e) {
3163       {
3164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3165       };
3166     } catch (...) {
3167       {
3168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3169       };
3170     }
3171   }
3172
3173   jresult = (void *)result;
3174   return jresult;
3175 }
3176
3177
3178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3179   uintp *arg1 = (uintp *) 0 ;
3180
3181   arg1 = (uintp *)jarg1;
3182   {
3183     try {
3184       delete_uintp(arg1);
3185     } catch (std::out_of_range& e) {
3186       {
3187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3188       };
3189     } catch (std::exception& e) {
3190       {
3191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3192       };
3193     } catch (Dali::DaliException e) {
3194       {
3195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3196       };
3197     } catch (...) {
3198       {
3199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3200       };
3201     }
3202   }
3203
3204 }
3205
3206
3207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3208   uintp *arg1 = (uintp *) 0 ;
3209   unsigned int arg2 ;
3210
3211   arg1 = (uintp *)jarg1;
3212   arg2 = (unsigned int)jarg2;
3213   {
3214     try {
3215       uintp_assign(arg1,arg2);
3216     } catch (std::out_of_range& e) {
3217       {
3218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3219       };
3220     } catch (std::exception& e) {
3221       {
3222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3223       };
3224     } catch (Dali::DaliException e) {
3225       {
3226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3227       };
3228     } catch (...) {
3229       {
3230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3231       };
3232     }
3233   }
3234
3235 }
3236
3237
3238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3239   unsigned int jresult ;
3240   uintp *arg1 = (uintp *) 0 ;
3241   unsigned int result;
3242
3243   arg1 = (uintp *)jarg1;
3244   {
3245     try {
3246       result = (unsigned int)uintp_value(arg1);
3247     } catch (std::out_of_range& e) {
3248       {
3249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3250       };
3251     } catch (std::exception& e) {
3252       {
3253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3254       };
3255     } catch (Dali::DaliException e) {
3256       {
3257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3258       };
3259     } catch (...) {
3260       {
3261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3262       };
3263     }
3264   }
3265
3266   jresult = result;
3267   return jresult;
3268 }
3269
3270
3271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3272   void * jresult ;
3273   uintp *arg1 = (uintp *) 0 ;
3274   unsigned int *result = 0 ;
3275
3276   arg1 = (uintp *)jarg1;
3277   {
3278     try {
3279       result = (unsigned int *)uintp_cast(arg1);
3280     } catch (std::out_of_range& e) {
3281       {
3282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3283       };
3284     } catch (std::exception& e) {
3285       {
3286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3287       };
3288     } catch (Dali::DaliException e) {
3289       {
3290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3291       };
3292     } catch (...) {
3293       {
3294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3295       };
3296     }
3297   }
3298
3299   jresult = (void *)result;
3300   return jresult;
3301 }
3302
3303
3304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3305   void * jresult ;
3306   unsigned int *arg1 = (unsigned int *) 0 ;
3307   uintp *result = 0 ;
3308
3309   arg1 = (unsigned int *)jarg1;
3310   {
3311     try {
3312       result = (uintp *)uintp_frompointer(arg1);
3313     } catch (std::out_of_range& e) {
3314       {
3315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3316       };
3317     } catch (std::exception& e) {
3318       {
3319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3320       };
3321     } catch (Dali::DaliException e) {
3322       {
3323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3324       };
3325     } catch (...) {
3326       {
3327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3328       };
3329     }
3330   }
3331
3332   jresult = (void *)result;
3333   return jresult;
3334 }
3335
3336
3337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3338   void * jresult ;
3339   ushortp *result = 0 ;
3340
3341   {
3342     try {
3343       result = (ushortp *)new_ushortp();
3344     } catch (std::out_of_range& e) {
3345       {
3346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3347       };
3348     } catch (std::exception& e) {
3349       {
3350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3351       };
3352     } catch (Dali::DaliException e) {
3353       {
3354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3355       };
3356     } catch (...) {
3357       {
3358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3359       };
3360     }
3361   }
3362
3363   jresult = (void *)result;
3364   return jresult;
3365 }
3366
3367
3368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3369   ushortp *arg1 = (ushortp *) 0 ;
3370
3371   arg1 = (ushortp *)jarg1;
3372   {
3373     try {
3374       delete_ushortp(arg1);
3375     } catch (std::out_of_range& e) {
3376       {
3377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3378       };
3379     } catch (std::exception& e) {
3380       {
3381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3382       };
3383     } catch (Dali::DaliException e) {
3384       {
3385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3386       };
3387     } catch (...) {
3388       {
3389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3390       };
3391     }
3392   }
3393
3394 }
3395
3396
3397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3398   ushortp *arg1 = (ushortp *) 0 ;
3399   unsigned short arg2 ;
3400
3401   arg1 = (ushortp *)jarg1;
3402   arg2 = (unsigned short)jarg2;
3403   {
3404     try {
3405       ushortp_assign(arg1,arg2);
3406     } catch (std::out_of_range& e) {
3407       {
3408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3409       };
3410     } catch (std::exception& e) {
3411       {
3412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3413       };
3414     } catch (Dali::DaliException e) {
3415       {
3416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3417       };
3418     } catch (...) {
3419       {
3420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3421       };
3422     }
3423   }
3424
3425 }
3426
3427
3428 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3429   unsigned short jresult ;
3430   ushortp *arg1 = (ushortp *) 0 ;
3431   unsigned short result;
3432
3433   arg1 = (ushortp *)jarg1;
3434   {
3435     try {
3436       result = (unsigned short)ushortp_value(arg1);
3437     } catch (std::out_of_range& e) {
3438       {
3439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3440       };
3441     } catch (std::exception& e) {
3442       {
3443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3444       };
3445     } catch (Dali::DaliException e) {
3446       {
3447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3448       };
3449     } catch (...) {
3450       {
3451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3452       };
3453     }
3454   }
3455
3456   jresult = result;
3457   return jresult;
3458 }
3459
3460
3461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3462   void * jresult ;
3463   ushortp *arg1 = (ushortp *) 0 ;
3464   unsigned short *result = 0 ;
3465
3466   arg1 = (ushortp *)jarg1;
3467   {
3468     try {
3469       result = (unsigned short *)ushortp_cast(arg1);
3470     } catch (std::out_of_range& e) {
3471       {
3472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3473       };
3474     } catch (std::exception& e) {
3475       {
3476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3477       };
3478     } catch (Dali::DaliException e) {
3479       {
3480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3481       };
3482     } catch (...) {
3483       {
3484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3485       };
3486     }
3487   }
3488
3489   jresult = (void *)result;
3490   return jresult;
3491 }
3492
3493
3494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3495   void * jresult ;
3496   unsigned short *arg1 = (unsigned short *) 0 ;
3497   ushortp *result = 0 ;
3498
3499   arg1 = (unsigned short *)jarg1;
3500   {
3501     try {
3502       result = (ushortp *)ushortp_frompointer(arg1);
3503     } catch (std::out_of_range& e) {
3504       {
3505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3506       };
3507     } catch (std::exception& e) {
3508       {
3509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3510       };
3511     } catch (Dali::DaliException e) {
3512       {
3513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3514       };
3515     } catch (...) {
3516       {
3517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3518       };
3519     }
3520   }
3521
3522   jresult = (void *)result;
3523   return jresult;
3524 }
3525
3526
3527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3528   unsigned int jresult ;
3529   int arg1 ;
3530   unsigned int result;
3531
3532   arg1 = (int)jarg1;
3533   {
3534     try {
3535       result = (unsigned int)int_to_uint(arg1);
3536     } catch (std::out_of_range& e) {
3537       {
3538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3539       };
3540     } catch (std::exception& e) {
3541       {
3542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3543       };
3544     } catch (Dali::DaliException e) {
3545       {
3546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3547       };
3548     } catch (...) {
3549       {
3550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3551       };
3552     }
3553   }
3554
3555   jresult = result;
3556   return jresult;
3557 }
3558
3559
3560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3561   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3562
3563   arg1 = (Dali::RefObject *)jarg1;
3564   {
3565     try {
3566       (arg1)->Reference();
3567     } catch (std::out_of_range& e) {
3568       {
3569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3570       };
3571     } catch (std::exception& e) {
3572       {
3573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3574       };
3575     } catch (Dali::DaliException e) {
3576       {
3577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3578       };
3579     } catch (...) {
3580       {
3581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3582       };
3583     }
3584   }
3585
3586 }
3587
3588
3589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3590   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3591
3592   arg1 = (Dali::RefObject *)jarg1;
3593   {
3594     try {
3595       (arg1)->Unreference();
3596     } catch (std::out_of_range& e) {
3597       {
3598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3599       };
3600     } catch (std::exception& e) {
3601       {
3602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3603       };
3604     } catch (Dali::DaliException e) {
3605       {
3606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3607       };
3608     } catch (...) {
3609       {
3610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3611       };
3612     }
3613   }
3614
3615 }
3616
3617
3618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3619   int jresult ;
3620   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3621   int result;
3622
3623   arg1 = (Dali::RefObject *)jarg1;
3624   {
3625     try {
3626       result = (int)(arg1)->ReferenceCount();
3627     } catch (std::out_of_range& e) {
3628       {
3629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3630       };
3631     } catch (std::exception& e) {
3632       {
3633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3634       };
3635     } catch (Dali::DaliException e) {
3636       {
3637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3638       };
3639     } catch (...) {
3640       {
3641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3642       };
3643     }
3644   }
3645
3646   jresult = result;
3647   return jresult;
3648 }
3649
3650
3651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3652   void * jresult ;
3653   Dali::Any *result = 0 ;
3654
3655   {
3656     try {
3657       result = (Dali::Any *)new Dali::Any();
3658     } catch (std::out_of_range& e) {
3659       {
3660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3661       };
3662     } catch (std::exception& e) {
3663       {
3664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3665       };
3666     } catch (Dali::DaliException e) {
3667       {
3668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3669       };
3670     } catch (...) {
3671       {
3672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3673       };
3674     }
3675   }
3676
3677   jresult = (void *)result;
3678   return jresult;
3679 }
3680
3681
3682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3683   Dali::Any *arg1 = (Dali::Any *) 0 ;
3684
3685   arg1 = (Dali::Any *)jarg1;
3686   {
3687     try {
3688       delete arg1;
3689     } catch (std::out_of_range& e) {
3690       {
3691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3692       };
3693     } catch (std::exception& e) {
3694       {
3695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3696       };
3697     } catch (Dali::DaliException e) {
3698       {
3699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3700       };
3701     } catch (...) {
3702       {
3703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3704       };
3705     }
3706   }
3707
3708 }
3709
3710
3711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3712   char *arg1 = (char *) 0 ;
3713
3714   arg1 = (char *)jarg1;
3715   {
3716     try {
3717       Dali::Any::AssertAlways((char const *)arg1);
3718     } catch (std::out_of_range& e) {
3719       {
3720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3721       };
3722     } catch (std::exception& e) {
3723       {
3724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3725       };
3726     } catch (Dali::DaliException e) {
3727       {
3728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3729       };
3730     } catch (...) {
3731       {
3732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3733       };
3734     }
3735   }
3736
3737 }
3738
3739
3740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3741   void * jresult ;
3742   Dali::Any *arg1 = 0 ;
3743   Dali::Any *result = 0 ;
3744
3745   arg1 = (Dali::Any *)jarg1;
3746   if (!arg1) {
3747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3748     return 0;
3749   }
3750   {
3751     try {
3752       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3753     } catch (std::out_of_range& e) {
3754       {
3755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3756       };
3757     } catch (std::exception& e) {
3758       {
3759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3760       };
3761     } catch (Dali::DaliException e) {
3762       {
3763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3764       };
3765     } catch (...) {
3766       {
3767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3768       };
3769     }
3770   }
3771
3772   jresult = (void *)result;
3773   return jresult;
3774 }
3775
3776
3777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3778   void * jresult ;
3779   Dali::Any *arg1 = (Dali::Any *) 0 ;
3780   Dali::Any *arg2 = 0 ;
3781   Dali::Any *result = 0 ;
3782
3783   arg1 = (Dali::Any *)jarg1;
3784   arg2 = (Dali::Any *)jarg2;
3785   if (!arg2) {
3786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3787     return 0;
3788   }
3789   {
3790     try {
3791       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3792     } catch (std::out_of_range& e) {
3793       {
3794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3795       };
3796     } catch (std::exception& e) {
3797       {
3798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3799       };
3800     } catch (Dali::DaliException e) {
3801       {
3802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3803       };
3804     } catch (...) {
3805       {
3806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3807       };
3808     }
3809   }
3810
3811   jresult = (void *)result;
3812   return jresult;
3813 }
3814
3815
3816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3817   void * jresult ;
3818   Dali::Any *arg1 = (Dali::Any *) 0 ;
3819   std::type_info *result = 0 ;
3820
3821   arg1 = (Dali::Any *)jarg1;
3822   {
3823     try {
3824       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3825     } catch (std::out_of_range& e) {
3826       {
3827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3828       };
3829     } catch (std::exception& e) {
3830       {
3831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3832       };
3833     } catch (Dali::DaliException e) {
3834       {
3835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3836       };
3837     } catch (...) {
3838       {
3839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3840       };
3841     }
3842   }
3843
3844   jresult = (void *)result;
3845   return jresult;
3846 }
3847
3848
3849 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3850   unsigned int jresult ;
3851   Dali::Any *arg1 = (Dali::Any *) 0 ;
3852   bool result;
3853
3854   arg1 = (Dali::Any *)jarg1;
3855   {
3856     try {
3857       result = (bool)((Dali::Any const *)arg1)->Empty();
3858     } catch (std::out_of_range& e) {
3859       {
3860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3861       };
3862     } catch (std::exception& e) {
3863       {
3864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3865       };
3866     } catch (Dali::DaliException e) {
3867       {
3868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3869       };
3870     } catch (...) {
3871       {
3872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3873       };
3874     }
3875   }
3876
3877   jresult = result;
3878   return jresult;
3879 }
3880
3881
3882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3883   void * jresult ;
3884   std::type_info *arg1 = 0 ;
3885   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3886   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3887   Dali::Any::AnyContainerBase *result = 0 ;
3888
3889   arg1 = (std::type_info *)jarg1;
3890   if (!arg1) {
3891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3892     return 0;
3893   }
3894   arg2 = (Dali::Any::CloneFunc)jarg2;
3895   arg3 = (Dali::Any::DeleteFunc)jarg3;
3896   {
3897     try {
3898       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3899     } catch (std::out_of_range& e) {
3900       {
3901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3902       };
3903     } catch (std::exception& e) {
3904       {
3905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3906       };
3907     } catch (Dali::DaliException e) {
3908       {
3909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3910       };
3911     } catch (...) {
3912       {
3913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3914       };
3915     }
3916   }
3917
3918   jresult = (void *)result;
3919   return jresult;
3920 }
3921
3922
3923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3924   void * jresult ;
3925   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3926   std::type_info *result = 0 ;
3927
3928   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3929   {
3930     try {
3931       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3932     } catch (std::out_of_range& e) {
3933       {
3934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3935       };
3936     } catch (std::exception& e) {
3937       {
3938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3939       };
3940     } catch (Dali::DaliException e) {
3941       {
3942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3943       };
3944     } catch (...) {
3945       {
3946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3947       };
3948     }
3949   }
3950
3951   jresult = (void *)result;
3952   return jresult;
3953 }
3954
3955
3956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3957   void * jresult ;
3958   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3959   ::std::type_info *result = 0 ;
3960
3961   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3962   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3963   jresult = (void *)result;
3964   return jresult;
3965 }
3966
3967
3968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3969   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3970   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3971
3972   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3973   arg2 = (Dali::Any::CloneFunc)jarg2;
3974   if (arg1) (arg1)->mCloneFunc = arg2;
3975 }
3976
3977
3978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3979   void * jresult ;
3980   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3981   Dali::Any::CloneFunc result;
3982
3983   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3984   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3985   jresult = (void *)result;
3986   return jresult;
3987 }
3988
3989
3990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3991   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3992   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3993
3994   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3995   arg2 = (Dali::Any::DeleteFunc)jarg2;
3996   if (arg1) (arg1)->mDeleteFunc = arg2;
3997 }
3998
3999
4000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4001   void * jresult ;
4002   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4003   Dali::Any::DeleteFunc result;
4004
4005   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4006   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4007   jresult = (void *)result;
4008   return jresult;
4009 }
4010
4011
4012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4013   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4014
4015   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4016   {
4017     try {
4018       delete arg1;
4019     } catch (std::out_of_range& e) {
4020       {
4021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4022       };
4023     } catch (std::exception& e) {
4024       {
4025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4026       };
4027     } catch (Dali::DaliException e) {
4028       {
4029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4030       };
4031     } catch (...) {
4032       {
4033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4034       };
4035     }
4036   }
4037
4038 }
4039
4040
4041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4042   Dali::Any *arg1 = (Dali::Any *) 0 ;
4043   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4044
4045   arg1 = (Dali::Any *)jarg1;
4046   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4047   if (arg1) (arg1)->mContainer = arg2;
4048 }
4049
4050
4051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4052   void * jresult ;
4053   Dali::Any *arg1 = (Dali::Any *) 0 ;
4054   Dali::Any::AnyContainerBase *result = 0 ;
4055
4056   arg1 = (Dali::Any *)jarg1;
4057   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4058   jresult = (void *)result;
4059   return jresult;
4060 }
4061
4062
4063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4064   char *arg1 = (char *) 0 ;
4065   char *arg2 = (char *) 0 ;
4066
4067   arg1 = (char *)jarg1;
4068   arg2 = (char *)jarg2;
4069   {
4070     try {
4071       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4072     } catch (std::out_of_range& e) {
4073       {
4074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4075       };
4076     } catch (std::exception& e) {
4077       {
4078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4079       };
4080     } catch (Dali::DaliException e) {
4081       {
4082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4083       };
4084     } catch (...) {
4085       {
4086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4087       };
4088     }
4089   }
4090
4091 }
4092
4093
4094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4095   void * jresult ;
4096   char *arg1 = (char *) 0 ;
4097   char *arg2 = (char *) 0 ;
4098   Dali::DaliException *result = 0 ;
4099
4100   arg1 = (char *)jarg1;
4101   arg2 = (char *)jarg2;
4102   {
4103     try {
4104       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4105     } catch (std::out_of_range& e) {
4106       {
4107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4108       };
4109     } catch (std::exception& e) {
4110       {
4111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4112       };
4113     } catch (Dali::DaliException e) {
4114       {
4115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4116       };
4117     } catch (...) {
4118       {
4119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4120       };
4121     }
4122   }
4123
4124   jresult = (void *)result;
4125   return jresult;
4126 }
4127
4128
4129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4130   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4131   std::string arg2 = std::string(jarg2);
4132
4133   arg1 = (Dali::DaliException *)jarg1;
4134   {
4135     if (!arg2.empty()) {
4136       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4137     } else {
4138       arg1->location = 0;
4139     }
4140   }
4141 }
4142
4143 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4144   char * jresult ;
4145   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4146   char *result = 0 ;
4147
4148   arg1 = (Dali::DaliException *)jarg1;
4149   result = (char *) ((arg1)->location);
4150   jresult = SWIG_csharp_string_callback((const char *)result);
4151   return jresult;
4152 }
4153
4154
4155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4156   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4157   std::string arg2 = std::string(jarg2);
4158
4159   arg1 = (Dali::DaliException *)jarg1;
4160   {
4161     if (!arg2.empty()) {
4162       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4163     } else {
4164       arg1->condition = 0;
4165     }
4166   }
4167 }
4168
4169
4170 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4171   char * jresult ;
4172   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4173   char *result = 0 ;
4174
4175   arg1 = (Dali::DaliException *)jarg1;
4176   result = (char *) ((arg1)->condition);
4177   jresult = SWIG_csharp_string_callback((const char *)result);
4178   return jresult;
4179 }
4180
4181
4182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4183   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4184
4185   arg1 = (Dali::DaliException *)jarg1;
4186   {
4187     try {
4188       delete arg1;
4189     } catch (std::out_of_range& e) {
4190       {
4191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4192       };
4193     } catch (std::exception& e) {
4194       {
4195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4196       };
4197     } catch (Dali::DaliException e) {
4198       {
4199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4200       };
4201     } catch (...) {
4202       {
4203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4204       };
4205     }
4206   }
4207
4208 }
4209
4210
4211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4212   void * jresult ;
4213   Dali::Vector2 *result = 0 ;
4214
4215   {
4216     try {
4217       result = (Dali::Vector2 *)new Dali::Vector2();
4218     } catch (std::out_of_range& e) {
4219       {
4220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4221       };
4222     } catch (std::exception& e) {
4223       {
4224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4225       };
4226     } catch (Dali::DaliException e) {
4227       {
4228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4229       };
4230     } catch (...) {
4231       {
4232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4233       };
4234     }
4235   }
4236
4237   jresult = (void *)result;
4238   return jresult;
4239 }
4240
4241
4242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4243   void * jresult ;
4244   float arg1 ;
4245   float arg2 ;
4246   Dali::Vector2 *result = 0 ;
4247
4248   arg1 = (float)jarg1;
4249   arg2 = (float)jarg2;
4250   {
4251     try {
4252       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4253     } catch (std::out_of_range& e) {
4254       {
4255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4256       };
4257     } catch (std::exception& e) {
4258       {
4259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4260       };
4261     } catch (Dali::DaliException e) {
4262       {
4263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4264       };
4265     } catch (...) {
4266       {
4267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4268       };
4269     }
4270   }
4271
4272   jresult = (void *)result;
4273   return jresult;
4274 }
4275
4276
4277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4278   void * jresult ;
4279   float *arg1 = (float *) 0 ;
4280   Dali::Vector2 *result = 0 ;
4281
4282   arg1 = jarg1;
4283   {
4284     try {
4285       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4286     } catch (std::out_of_range& e) {
4287       {
4288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4289       };
4290     } catch (std::exception& e) {
4291       {
4292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4293       };
4294     } catch (Dali::DaliException e) {
4295       {
4296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4297       };
4298     } catch (...) {
4299       {
4300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4301       };
4302     }
4303   }
4304
4305   jresult = (void *)result;
4306
4307
4308   return jresult;
4309 }
4310
4311
4312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4313   void * jresult ;
4314   Dali::Vector3 *arg1 = 0 ;
4315   Dali::Vector2 *result = 0 ;
4316
4317   arg1 = (Dali::Vector3 *)jarg1;
4318   if (!arg1) {
4319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4320     return 0;
4321   }
4322   {
4323     try {
4324       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4325     } catch (std::out_of_range& e) {
4326       {
4327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4328       };
4329     } catch (std::exception& e) {
4330       {
4331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4332       };
4333     } catch (Dali::DaliException e) {
4334       {
4335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4336       };
4337     } catch (...) {
4338       {
4339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4340       };
4341     }
4342   }
4343
4344   jresult = (void *)result;
4345   return jresult;
4346 }
4347
4348
4349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4350   void * jresult ;
4351   Dali::Vector4 *arg1 = 0 ;
4352   Dali::Vector2 *result = 0 ;
4353
4354   arg1 = (Dali::Vector4 *)jarg1;
4355   if (!arg1) {
4356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4357     return 0;
4358   }
4359   {
4360     try {
4361       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4362     } catch (std::out_of_range& e) {
4363       {
4364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4365       };
4366     } catch (std::exception& e) {
4367       {
4368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4369       };
4370     } catch (Dali::DaliException e) {
4371       {
4372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4373       };
4374     } catch (...) {
4375       {
4376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4377       };
4378     }
4379   }
4380
4381   jresult = (void *)result;
4382   return jresult;
4383 }
4384
4385
4386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4387   void * jresult ;
4388   Dali::Vector2 *result = 0 ;
4389
4390   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4391   jresult = (void *)result;
4392   return jresult;
4393 }
4394
4395
4396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4397   void * jresult ;
4398   Dali::Vector2 *result = 0 ;
4399
4400   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4401   jresult = (void *)result;
4402   return jresult;
4403 }
4404
4405
4406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4407   void * jresult ;
4408   Dali::Vector2 *result = 0 ;
4409
4410   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4411   jresult = (void *)result;
4412   return jresult;
4413 }
4414
4415
4416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4417   void * jresult ;
4418   Dali::Vector2 *result = 0 ;
4419
4420   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4421   jresult = (void *)result;
4422   return jresult;
4423 }
4424
4425
4426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4427   void * jresult ;
4428   Dali::Vector2 *result = 0 ;
4429
4430   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4431   jresult = (void *)result;
4432   return jresult;
4433 }
4434
4435
4436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4437   void * jresult ;
4438   Dali::Vector2 *result = 0 ;
4439
4440   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4441   jresult = (void *)result;
4442   return jresult;
4443 }
4444
4445
4446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4447   void * jresult ;
4448   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4449   float *arg2 = (float *) 0 ;
4450   Dali::Vector2 *result = 0 ;
4451
4452   arg1 = (Dali::Vector2 *)jarg1;
4453   arg2 = jarg2;
4454   {
4455     try {
4456       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4457     } catch (std::out_of_range& e) {
4458       {
4459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4460       };
4461     } catch (std::exception& e) {
4462       {
4463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4464       };
4465     } catch (Dali::DaliException e) {
4466       {
4467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4468       };
4469     } catch (...) {
4470       {
4471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4472       };
4473     }
4474   }
4475
4476   jresult = (void *)result;
4477
4478
4479   return jresult;
4480 }
4481
4482
4483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4484   void * jresult ;
4485   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4486   Dali::Vector3 *arg2 = 0 ;
4487   Dali::Vector2 *result = 0 ;
4488
4489   arg1 = (Dali::Vector2 *)jarg1;
4490   arg2 = (Dali::Vector3 *)jarg2;
4491   if (!arg2) {
4492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4493     return 0;
4494   }
4495   {
4496     try {
4497       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4498     } catch (std::out_of_range& e) {
4499       {
4500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4501       };
4502     } catch (std::exception& e) {
4503       {
4504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4505       };
4506     } catch (Dali::DaliException e) {
4507       {
4508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4509       };
4510     } catch (...) {
4511       {
4512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4513       };
4514     }
4515   }
4516
4517   jresult = (void *)result;
4518   return jresult;
4519 }
4520
4521
4522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4523   void * jresult ;
4524   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4525   Dali::Vector4 *arg2 = 0 ;
4526   Dali::Vector2 *result = 0 ;
4527
4528   arg1 = (Dali::Vector2 *)jarg1;
4529   arg2 = (Dali::Vector4 *)jarg2;
4530   if (!arg2) {
4531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4532     return 0;
4533   }
4534   {
4535     try {
4536       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4537     } catch (std::out_of_range& e) {
4538       {
4539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4540       };
4541     } catch (std::exception& e) {
4542       {
4543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4544       };
4545     } catch (Dali::DaliException e) {
4546       {
4547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4548       };
4549     } catch (...) {
4550       {
4551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4552       };
4553     }
4554   }
4555
4556   jresult = (void *)result;
4557   return jresult;
4558 }
4559
4560
4561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4562   void * jresult ;
4563   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4564   Dali::Vector2 *arg2 = 0 ;
4565   Dali::Vector2 result;
4566
4567   arg1 = (Dali::Vector2 *)jarg1;
4568   arg2 = (Dali::Vector2 *)jarg2;
4569   if (!arg2) {
4570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4571     return 0;
4572   }
4573   {
4574     try {
4575       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4576     } catch (std::out_of_range& e) {
4577       {
4578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4579       };
4580     } catch (std::exception& e) {
4581       {
4582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4583       };
4584     } catch (Dali::DaliException e) {
4585       {
4586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4587       };
4588     } catch (...) {
4589       {
4590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4591       };
4592     }
4593   }
4594
4595   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4596   return jresult;
4597 }
4598
4599
4600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4601   void * jresult ;
4602   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4603   Dali::Vector2 *arg2 = 0 ;
4604   Dali::Vector2 *result = 0 ;
4605
4606   arg1 = (Dali::Vector2 *)jarg1;
4607   arg2 = (Dali::Vector2 *)jarg2;
4608   if (!arg2) {
4609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4610     return 0;
4611   }
4612   {
4613     try {
4614       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4615     } catch (std::out_of_range& e) {
4616       {
4617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4618       };
4619     } catch (std::exception& e) {
4620       {
4621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4622       };
4623     } catch (Dali::DaliException e) {
4624       {
4625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4626       };
4627     } catch (...) {
4628       {
4629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4630       };
4631     }
4632   }
4633
4634   jresult = (void *)result;
4635   return jresult;
4636 }
4637
4638
4639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4640   void * jresult ;
4641   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4642   Dali::Vector2 *arg2 = 0 ;
4643   Dali::Vector2 result;
4644
4645   arg1 = (Dali::Vector2 *)jarg1;
4646   arg2 = (Dali::Vector2 *)jarg2;
4647   if (!arg2) {
4648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4649     return 0;
4650   }
4651   {
4652     try {
4653       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4654     } catch (std::out_of_range& e) {
4655       {
4656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4657       };
4658     } catch (std::exception& e) {
4659       {
4660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4661       };
4662     } catch (Dali::DaliException e) {
4663       {
4664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4665       };
4666     } catch (...) {
4667       {
4668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4669       };
4670     }
4671   }
4672
4673   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4674   return jresult;
4675 }
4676
4677
4678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4679   void * jresult ;
4680   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4681   Dali::Vector2 *arg2 = 0 ;
4682   Dali::Vector2 *result = 0 ;
4683
4684   arg1 = (Dali::Vector2 *)jarg1;
4685   arg2 = (Dali::Vector2 *)jarg2;
4686   if (!arg2) {
4687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4688     return 0;
4689   }
4690   {
4691     try {
4692       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4693     } catch (std::out_of_range& e) {
4694       {
4695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4696       };
4697     } catch (std::exception& e) {
4698       {
4699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4700       };
4701     } catch (Dali::DaliException e) {
4702       {
4703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4704       };
4705     } catch (...) {
4706       {
4707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4708       };
4709     }
4710   }
4711
4712   jresult = (void *)result;
4713   return jresult;
4714 }
4715
4716
4717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4718   void * jresult ;
4719   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4720   Dali::Vector2 *arg2 = 0 ;
4721   Dali::Vector2 result;
4722
4723   arg1 = (Dali::Vector2 *)jarg1;
4724   arg2 = (Dali::Vector2 *)jarg2;
4725   if (!arg2) {
4726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4727     return 0;
4728   }
4729   {
4730     try {
4731       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4732     } catch (std::out_of_range& e) {
4733       {
4734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4735       };
4736     } catch (std::exception& e) {
4737       {
4738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4739       };
4740     } catch (Dali::DaliException e) {
4741       {
4742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4743       };
4744     } catch (...) {
4745       {
4746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4747       };
4748     }
4749   }
4750
4751   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4752   return jresult;
4753 }
4754
4755
4756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4757   void * jresult ;
4758   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4759   float arg2 ;
4760   Dali::Vector2 result;
4761
4762   arg1 = (Dali::Vector2 *)jarg1;
4763   arg2 = (float)jarg2;
4764   {
4765     try {
4766       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4767     } catch (std::out_of_range& e) {
4768       {
4769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4770       };
4771     } catch (std::exception& e) {
4772       {
4773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4774       };
4775     } catch (Dali::DaliException e) {
4776       {
4777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4778       };
4779     } catch (...) {
4780       {
4781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4782       };
4783     }
4784   }
4785
4786   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4787   return jresult;
4788 }
4789
4790
4791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4792   void * jresult ;
4793   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4794   Dali::Vector2 *arg2 = 0 ;
4795   Dali::Vector2 *result = 0 ;
4796
4797   arg1 = (Dali::Vector2 *)jarg1;
4798   arg2 = (Dali::Vector2 *)jarg2;
4799   if (!arg2) {
4800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4801     return 0;
4802   }
4803   {
4804     try {
4805       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4806     } catch (std::out_of_range& e) {
4807       {
4808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4809       };
4810     } catch (std::exception& e) {
4811       {
4812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4813       };
4814     } catch (Dali::DaliException e) {
4815       {
4816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4817       };
4818     } catch (...) {
4819       {
4820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4821       };
4822     }
4823   }
4824
4825   jresult = (void *)result;
4826   return jresult;
4827 }
4828
4829
4830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4831   void * jresult ;
4832   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4833   float arg2 ;
4834   Dali::Vector2 *result = 0 ;
4835
4836   arg1 = (Dali::Vector2 *)jarg1;
4837   arg2 = (float)jarg2;
4838   {
4839     try {
4840       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4841     } catch (std::out_of_range& e) {
4842       {
4843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4844       };
4845     } catch (std::exception& e) {
4846       {
4847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4848       };
4849     } catch (Dali::DaliException e) {
4850       {
4851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4852       };
4853     } catch (...) {
4854       {
4855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4856       };
4857     }
4858   }
4859
4860   jresult = (void *)result;
4861   return jresult;
4862 }
4863
4864
4865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4866   void * jresult ;
4867   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4868   Dali::Vector2 *arg2 = 0 ;
4869   Dali::Vector2 result;
4870
4871   arg1 = (Dali::Vector2 *)jarg1;
4872   arg2 = (Dali::Vector2 *)jarg2;
4873   if (!arg2) {
4874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4875     return 0;
4876   }
4877   {
4878     try {
4879       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4880     } catch (std::out_of_range& e) {
4881       {
4882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4883       };
4884     } catch (std::exception& e) {
4885       {
4886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4887       };
4888     } catch (Dali::DaliException e) {
4889       {
4890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4891       };
4892     } catch (...) {
4893       {
4894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4895       };
4896     }
4897   }
4898
4899   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4900   return jresult;
4901 }
4902
4903
4904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4905   void * jresult ;
4906   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4907   float arg2 ;
4908   Dali::Vector2 result;
4909
4910   arg1 = (Dali::Vector2 *)jarg1;
4911   arg2 = (float)jarg2;
4912   {
4913     try {
4914       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4915     } catch (std::out_of_range& e) {
4916       {
4917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4918       };
4919     } catch (std::exception& e) {
4920       {
4921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4922       };
4923     } catch (Dali::DaliException e) {
4924       {
4925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4926       };
4927     } catch (...) {
4928       {
4929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4930       };
4931     }
4932   }
4933
4934   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4935   return jresult;
4936 }
4937
4938
4939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4940   void * jresult ;
4941   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4942   Dali::Vector2 *arg2 = 0 ;
4943   Dali::Vector2 *result = 0 ;
4944
4945   arg1 = (Dali::Vector2 *)jarg1;
4946   arg2 = (Dali::Vector2 *)jarg2;
4947   if (!arg2) {
4948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4949     return 0;
4950   }
4951   {
4952     try {
4953       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4954     } catch (std::out_of_range& e) {
4955       {
4956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4957       };
4958     } catch (std::exception& e) {
4959       {
4960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4961       };
4962     } catch (Dali::DaliException e) {
4963       {
4964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4965       };
4966     } catch (...) {
4967       {
4968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4969       };
4970     }
4971   }
4972
4973   jresult = (void *)result;
4974   return jresult;
4975 }
4976
4977
4978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4979   void * jresult ;
4980   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4981   float arg2 ;
4982   Dali::Vector2 *result = 0 ;
4983
4984   arg1 = (Dali::Vector2 *)jarg1;
4985   arg2 = (float)jarg2;
4986   {
4987     try {
4988       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4989     } catch (std::out_of_range& e) {
4990       {
4991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4992       };
4993     } catch (std::exception& e) {
4994       {
4995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4996       };
4997     } catch (Dali::DaliException e) {
4998       {
4999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5000       };
5001     } catch (...) {
5002       {
5003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5004       };
5005     }
5006   }
5007
5008   jresult = (void *)result;
5009   return jresult;
5010 }
5011
5012
5013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5014   void * jresult ;
5015   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5016   Dali::Vector2 result;
5017
5018   arg1 = (Dali::Vector2 *)jarg1;
5019   {
5020     try {
5021       result = ((Dali::Vector2 const *)arg1)->operator -();
5022     } catch (std::out_of_range& e) {
5023       {
5024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5025       };
5026     } catch (std::exception& e) {
5027       {
5028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5029       };
5030     } catch (Dali::DaliException e) {
5031       {
5032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5033       };
5034     } catch (...) {
5035       {
5036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5037       };
5038     }
5039   }
5040
5041   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5042   return jresult;
5043 }
5044
5045
5046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5047   unsigned int jresult ;
5048   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5049   Dali::Vector2 *arg2 = 0 ;
5050   bool result;
5051
5052   arg1 = (Dali::Vector2 *)jarg1;
5053   arg2 = (Dali::Vector2 *)jarg2;
5054   if (!arg2) {
5055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5056     return 0;
5057   }
5058   {
5059     try {
5060       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5061     } catch (std::out_of_range& e) {
5062       {
5063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5064       };
5065     } catch (std::exception& e) {
5066       {
5067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5068       };
5069     } catch (Dali::DaliException e) {
5070       {
5071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5072       };
5073     } catch (...) {
5074       {
5075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5076       };
5077     }
5078   }
5079
5080   jresult = result;
5081   return jresult;
5082 }
5083
5084
5085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5086   unsigned int jresult ;
5087   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5088   Dali::Vector2 *arg2 = 0 ;
5089   bool result;
5090
5091   arg1 = (Dali::Vector2 *)jarg1;
5092   arg2 = (Dali::Vector2 *)jarg2;
5093   if (!arg2) {
5094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5095     return 0;
5096   }
5097   {
5098     try {
5099       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5100     } catch (std::out_of_range& e) {
5101       {
5102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5103       };
5104     } catch (std::exception& e) {
5105       {
5106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5107       };
5108     } catch (Dali::DaliException e) {
5109       {
5110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5111       };
5112     } catch (...) {
5113       {
5114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5115       };
5116     }
5117   }
5118
5119   jresult = result;
5120   return jresult;
5121 }
5122
5123
5124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5125   float jresult ;
5126   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5127   unsigned int arg2 ;
5128   float *result = 0 ;
5129
5130   arg1 = (Dali::Vector2 *)jarg1;
5131   arg2 = (unsigned int)jarg2;
5132   {
5133     try {
5134       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5135     } catch (std::out_of_range& e) {
5136       {
5137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5138       };
5139     } catch (std::exception& e) {
5140       {
5141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5142       };
5143     } catch (Dali::DaliException e) {
5144       {
5145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5146       };
5147     } catch (...) {
5148       {
5149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5150       };
5151     }
5152   }
5153
5154   jresult = *result;
5155   return jresult;
5156 }
5157
5158
5159 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5160   float jresult ;
5161   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5162   float result;
5163
5164   arg1 = (Dali::Vector2 *)jarg1;
5165   {
5166     try {
5167       result = (float)((Dali::Vector2 const *)arg1)->Length();
5168     } catch (std::out_of_range& e) {
5169       {
5170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5171       };
5172     } catch (std::exception& e) {
5173       {
5174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5175       };
5176     } catch (Dali::DaliException e) {
5177       {
5178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5179       };
5180     } catch (...) {
5181       {
5182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5183       };
5184     }
5185   }
5186
5187   jresult = result;
5188   return jresult;
5189 }
5190
5191
5192 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5193   float jresult ;
5194   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5195   float result;
5196
5197   arg1 = (Dali::Vector2 *)jarg1;
5198   {
5199     try {
5200       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5201     } catch (std::out_of_range& e) {
5202       {
5203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5204       };
5205     } catch (std::exception& e) {
5206       {
5207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5208       };
5209     } catch (Dali::DaliException e) {
5210       {
5211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5212       };
5213     } catch (...) {
5214       {
5215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5216       };
5217     }
5218   }
5219
5220   jresult = result;
5221   return jresult;
5222 }
5223
5224
5225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5226   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5227
5228   arg1 = (Dali::Vector2 *)jarg1;
5229   {
5230     try {
5231       (arg1)->Normalize();
5232     } catch (std::out_of_range& e) {
5233       {
5234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5235       };
5236     } catch (std::exception& e) {
5237       {
5238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5239       };
5240     } catch (Dali::DaliException e) {
5241       {
5242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5243       };
5244     } catch (...) {
5245       {
5246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5247       };
5248     }
5249   }
5250
5251 }
5252
5253
5254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5255   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5256   Dali::Vector2 *arg2 = 0 ;
5257   Dali::Vector2 *arg3 = 0 ;
5258
5259   arg1 = (Dali::Vector2 *)jarg1;
5260   arg2 = (Dali::Vector2 *)jarg2;
5261   if (!arg2) {
5262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5263     return ;
5264   }
5265   arg3 = (Dali::Vector2 *)jarg3;
5266   if (!arg3) {
5267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5268     return ;
5269   }
5270   {
5271     try {
5272       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5273     } catch (std::out_of_range& e) {
5274       {
5275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5276       };
5277     } catch (std::exception& e) {
5278       {
5279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5280       };
5281     } catch (Dali::DaliException e) {
5282       {
5283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5284       };
5285     } catch (...) {
5286       {
5287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5288       };
5289     }
5290   }
5291
5292 }
5293
5294
5295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5296   void * jresult ;
5297   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5298   float *result = 0 ;
5299
5300   arg1 = (Dali::Vector2 *)jarg1;
5301   {
5302     try {
5303       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5304     } catch (std::out_of_range& e) {
5305       {
5306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5307       };
5308     } catch (std::exception& e) {
5309       {
5310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5311       };
5312     } catch (Dali::DaliException e) {
5313       {
5314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5315       };
5316     } catch (...) {
5317       {
5318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5319       };
5320     }
5321   }
5322
5323   jresult = (void *)result;
5324   return jresult;
5325 }
5326
5327
5328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5329   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5330   float arg2 ;
5331
5332   arg1 = (Dali::Vector2 *)jarg1;
5333   arg2 = (float)jarg2;
5334   if (arg1) (arg1)->x = arg2;
5335 }
5336
5337
5338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5339   float jresult ;
5340   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5341   float result;
5342
5343   arg1 = (Dali::Vector2 *)jarg1;
5344   result = (float) ((arg1)->x);
5345   jresult = result;
5346   return jresult;
5347 }
5348
5349
5350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5351   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5352   float arg2 ;
5353
5354   arg1 = (Dali::Vector2 *)jarg1;
5355   arg2 = (float)jarg2;
5356   if (arg1) (arg1)->width = arg2;
5357 }
5358
5359
5360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5361   float jresult ;
5362   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5363   float result;
5364
5365   arg1 = (Dali::Vector2 *)jarg1;
5366   result = (float) ((arg1)->width);
5367   jresult = result;
5368   return jresult;
5369 }
5370
5371
5372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5373   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5374   float arg2 ;
5375
5376   arg1 = (Dali::Vector2 *)jarg1;
5377   arg2 = (float)jarg2;
5378   if (arg1) (arg1)->y = arg2;
5379 }
5380
5381
5382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5383   float jresult ;
5384   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5385   float result;
5386
5387   arg1 = (Dali::Vector2 *)jarg1;
5388   result = (float) ((arg1)->y);
5389   jresult = result;
5390   return jresult;
5391 }
5392
5393
5394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5395   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5396   float arg2 ;
5397
5398   arg1 = (Dali::Vector2 *)jarg1;
5399   arg2 = (float)jarg2;
5400   if (arg1) (arg1)->height = arg2;
5401 }
5402
5403
5404 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5405   float jresult ;
5406   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5407   float result;
5408
5409   arg1 = (Dali::Vector2 *)jarg1;
5410   result = (float) ((arg1)->height);
5411   jresult = result;
5412   return jresult;
5413 }
5414
5415
5416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5417   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5418
5419   arg1 = (Dali::Vector2 *)jarg1;
5420   {
5421     try {
5422       delete arg1;
5423     } catch (std::out_of_range& e) {
5424       {
5425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5426       };
5427     } catch (std::exception& e) {
5428       {
5429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5430       };
5431     } catch (Dali::DaliException e) {
5432       {
5433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5434       };
5435     } catch (...) {
5436       {
5437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5438       };
5439     }
5440   }
5441
5442 }
5443
5444
5445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5446   void * jresult ;
5447   Dali::Vector2 *arg1 = 0 ;
5448   Dali::Vector2 *arg2 = 0 ;
5449   Dali::Vector2 result;
5450
5451   arg1 = (Dali::Vector2 *)jarg1;
5452   if (!arg1) {
5453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5454     return 0;
5455   }
5456   arg2 = (Dali::Vector2 *)jarg2;
5457   if (!arg2) {
5458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5459     return 0;
5460   }
5461   {
5462     try {
5463       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5464     } catch (std::out_of_range& e) {
5465       {
5466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5467       };
5468     } catch (std::exception& e) {
5469       {
5470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5471       };
5472     } catch (Dali::DaliException e) {
5473       {
5474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5475       };
5476     } catch (...) {
5477       {
5478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5479       };
5480     }
5481   }
5482
5483   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5484   return jresult;
5485 }
5486
5487
5488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5489   void * jresult ;
5490   Dali::Vector2 *arg1 = 0 ;
5491   Dali::Vector2 *arg2 = 0 ;
5492   Dali::Vector2 result;
5493
5494   arg1 = (Dali::Vector2 *)jarg1;
5495   if (!arg1) {
5496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5497     return 0;
5498   }
5499   arg2 = (Dali::Vector2 *)jarg2;
5500   if (!arg2) {
5501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5502     return 0;
5503   }
5504   {
5505     try {
5506       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5507     } catch (std::out_of_range& e) {
5508       {
5509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5510       };
5511     } catch (std::exception& e) {
5512       {
5513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5514       };
5515     } catch (Dali::DaliException e) {
5516       {
5517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5518       };
5519     } catch (...) {
5520       {
5521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5522       };
5523     }
5524   }
5525
5526   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5527   return jresult;
5528 }
5529
5530
5531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5532   void * jresult ;
5533   Dali::Vector2 *arg1 = 0 ;
5534   float *arg2 = 0 ;
5535   float *arg3 = 0 ;
5536   float temp2 ;
5537   float temp3 ;
5538   Dali::Vector2 result;
5539
5540   arg1 = (Dali::Vector2 *)jarg1;
5541   if (!arg1) {
5542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5543     return 0;
5544   }
5545   temp2 = (float)jarg2;
5546   arg2 = &temp2;
5547   temp3 = (float)jarg3;
5548   arg3 = &temp3;
5549   {
5550     try {
5551       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5552     } catch (std::out_of_range& e) {
5553       {
5554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5555       };
5556     } catch (std::exception& e) {
5557       {
5558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5559       };
5560     } catch (Dali::DaliException e) {
5561       {
5562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5563       };
5564     } catch (...) {
5565       {
5566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5567       };
5568     }
5569   }
5570
5571   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5572   return jresult;
5573 }
5574
5575
5576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5577   void * jresult ;
5578   Dali::Vector3 *result = 0 ;
5579
5580   {
5581     try {
5582       result = (Dali::Vector3 *)new Dali::Vector3();
5583     } catch (std::out_of_range& e) {
5584       {
5585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5586       };
5587     } catch (std::exception& e) {
5588       {
5589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5590       };
5591     } catch (Dali::DaliException e) {
5592       {
5593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5594       };
5595     } catch (...) {
5596       {
5597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5598       };
5599     }
5600   }
5601
5602   jresult = (void *)result;
5603   return jresult;
5604 }
5605
5606
5607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5608   void * jresult ;
5609   float arg1 ;
5610   float arg2 ;
5611   float arg3 ;
5612   Dali::Vector3 *result = 0 ;
5613
5614   arg1 = (float)jarg1;
5615   arg2 = (float)jarg2;
5616   arg3 = (float)jarg3;
5617   {
5618     try {
5619       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5620     } catch (std::out_of_range& e) {
5621       {
5622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5623       };
5624     } catch (std::exception& e) {
5625       {
5626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5627       };
5628     } catch (Dali::DaliException e) {
5629       {
5630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5631       };
5632     } catch (...) {
5633       {
5634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5635       };
5636     }
5637   }
5638
5639   jresult = (void *)result;
5640   return jresult;
5641 }
5642
5643
5644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5645   void * jresult ;
5646   float *arg1 = (float *) 0 ;
5647   Dali::Vector3 *result = 0 ;
5648
5649   arg1 = jarg1;
5650   {
5651     try {
5652       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5653     } catch (std::out_of_range& e) {
5654       {
5655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5656       };
5657     } catch (std::exception& e) {
5658       {
5659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5660       };
5661     } catch (Dali::DaliException e) {
5662       {
5663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5664       };
5665     } catch (...) {
5666       {
5667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5668       };
5669     }
5670   }
5671
5672   jresult = (void *)result;
5673
5674
5675   return jresult;
5676 }
5677
5678
5679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5680   void * jresult ;
5681   Dali::Vector2 *arg1 = 0 ;
5682   Dali::Vector3 *result = 0 ;
5683
5684   arg1 = (Dali::Vector2 *)jarg1;
5685   if (!arg1) {
5686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5687     return 0;
5688   }
5689   {
5690     try {
5691       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5692     } catch (std::out_of_range& e) {
5693       {
5694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5695       };
5696     } catch (std::exception& e) {
5697       {
5698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5699       };
5700     } catch (Dali::DaliException e) {
5701       {
5702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5703       };
5704     } catch (...) {
5705       {
5706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5707       };
5708     }
5709   }
5710
5711   jresult = (void *)result;
5712   return jresult;
5713 }
5714
5715
5716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5717   void * jresult ;
5718   Dali::Vector4 *arg1 = 0 ;
5719   Dali::Vector3 *result = 0 ;
5720
5721   arg1 = (Dali::Vector4 *)jarg1;
5722   if (!arg1) {
5723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5724     return 0;
5725   }
5726   {
5727     try {
5728       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5729     } catch (std::out_of_range& e) {
5730       {
5731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5732       };
5733     } catch (std::exception& e) {
5734       {
5735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5736       };
5737     } catch (Dali::DaliException e) {
5738       {
5739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5740       };
5741     } catch (...) {
5742       {
5743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5744       };
5745     }
5746   }
5747
5748   jresult = (void *)result;
5749   return jresult;
5750 }
5751
5752
5753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5754   void * jresult ;
5755   Dali::Vector3 *result = 0 ;
5756
5757   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5758   jresult = (void *)result;
5759   return jresult;
5760 }
5761
5762
5763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5764   void * jresult ;
5765   Dali::Vector3 *result = 0 ;
5766
5767   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5768   jresult = (void *)result;
5769   return jresult;
5770 }
5771
5772
5773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5774   void * jresult ;
5775   Dali::Vector3 *result = 0 ;
5776
5777   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5778   jresult = (void *)result;
5779   return jresult;
5780 }
5781
5782
5783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5784   void * jresult ;
5785   Dali::Vector3 *result = 0 ;
5786
5787   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5788   jresult = (void *)result;
5789   return jresult;
5790 }
5791
5792
5793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5794   void * jresult ;
5795   Dali::Vector3 *result = 0 ;
5796
5797   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5798   jresult = (void *)result;
5799   return jresult;
5800 }
5801
5802
5803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5804   void * jresult ;
5805   Dali::Vector3 *result = 0 ;
5806
5807   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5808   jresult = (void *)result;
5809   return jresult;
5810 }
5811
5812
5813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5814   void * jresult ;
5815   Dali::Vector3 *result = 0 ;
5816
5817   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5818   jresult = (void *)result;
5819   return jresult;
5820 }
5821
5822
5823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5824   void * jresult ;
5825   Dali::Vector3 *result = 0 ;
5826
5827   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5828   jresult = (void *)result;
5829   return jresult;
5830 }
5831
5832
5833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5834   void * jresult ;
5835   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5836   float *arg2 = (float *) 0 ;
5837   Dali::Vector3 *result = 0 ;
5838
5839   arg1 = (Dali::Vector3 *)jarg1;
5840   arg2 = jarg2;
5841   {
5842     try {
5843       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5844     } catch (std::out_of_range& e) {
5845       {
5846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5847       };
5848     } catch (std::exception& e) {
5849       {
5850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5851       };
5852     } catch (Dali::DaliException e) {
5853       {
5854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5855       };
5856     } catch (...) {
5857       {
5858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5859       };
5860     }
5861   }
5862
5863   jresult = (void *)result;
5864
5865
5866   return jresult;
5867 }
5868
5869
5870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5871   void * jresult ;
5872   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5873   Dali::Vector2 *arg2 = 0 ;
5874   Dali::Vector3 *result = 0 ;
5875
5876   arg1 = (Dali::Vector3 *)jarg1;
5877   arg2 = (Dali::Vector2 *)jarg2;
5878   if (!arg2) {
5879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5880     return 0;
5881   }
5882   {
5883     try {
5884       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5885     } catch (std::out_of_range& e) {
5886       {
5887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5888       };
5889     } catch (std::exception& e) {
5890       {
5891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5892       };
5893     } catch (Dali::DaliException e) {
5894       {
5895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5896       };
5897     } catch (...) {
5898       {
5899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5900       };
5901     }
5902   }
5903
5904   jresult = (void *)result;
5905   return jresult;
5906 }
5907
5908
5909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5910   void * jresult ;
5911   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5912   Dali::Vector4 *arg2 = 0 ;
5913   Dali::Vector3 *result = 0 ;
5914
5915   arg1 = (Dali::Vector3 *)jarg1;
5916   arg2 = (Dali::Vector4 *)jarg2;
5917   if (!arg2) {
5918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5919     return 0;
5920   }
5921   {
5922     try {
5923       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5924     } catch (std::out_of_range& e) {
5925       {
5926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5927       };
5928     } catch (std::exception& e) {
5929       {
5930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5931       };
5932     } catch (Dali::DaliException e) {
5933       {
5934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5935       };
5936     } catch (...) {
5937       {
5938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5939       };
5940     }
5941   }
5942
5943   jresult = (void *)result;
5944   return jresult;
5945 }
5946
5947
5948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5949   void * jresult ;
5950   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5951   Dali::Vector3 *arg2 = 0 ;
5952   Dali::Vector3 result;
5953
5954   arg1 = (Dali::Vector3 *)jarg1;
5955   arg2 = (Dali::Vector3 *)jarg2;
5956   if (!arg2) {
5957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5958     return 0;
5959   }
5960   {
5961     try {
5962       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5963     } catch (std::out_of_range& e) {
5964       {
5965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5966       };
5967     } catch (std::exception& e) {
5968       {
5969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5970       };
5971     } catch (Dali::DaliException e) {
5972       {
5973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5974       };
5975     } catch (...) {
5976       {
5977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5978       };
5979     }
5980   }
5981
5982   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5983   return jresult;
5984 }
5985
5986
5987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5988   void * jresult ;
5989   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5990   Dali::Vector3 *arg2 = 0 ;
5991   Dali::Vector3 *result = 0 ;
5992
5993   arg1 = (Dali::Vector3 *)jarg1;
5994   arg2 = (Dali::Vector3 *)jarg2;
5995   if (!arg2) {
5996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5997     return 0;
5998   }
5999   {
6000     try {
6001       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6002     } catch (std::out_of_range& e) {
6003       {
6004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6005       };
6006     } catch (std::exception& e) {
6007       {
6008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6009       };
6010     } catch (Dali::DaliException e) {
6011       {
6012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6013       };
6014     } catch (...) {
6015       {
6016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6017       };
6018     }
6019   }
6020
6021   jresult = (void *)result;
6022   return jresult;
6023 }
6024
6025
6026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6027   void * jresult ;
6028   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6029   Dali::Vector3 *arg2 = 0 ;
6030   Dali::Vector3 result;
6031
6032   arg1 = (Dali::Vector3 *)jarg1;
6033   arg2 = (Dali::Vector3 *)jarg2;
6034   if (!arg2) {
6035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6036     return 0;
6037   }
6038   {
6039     try {
6040       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6041     } catch (std::out_of_range& e) {
6042       {
6043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6044       };
6045     } catch (std::exception& e) {
6046       {
6047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6048       };
6049     } catch (Dali::DaliException e) {
6050       {
6051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6052       };
6053     } catch (...) {
6054       {
6055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6056       };
6057     }
6058   }
6059
6060   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6061   return jresult;
6062 }
6063
6064
6065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6066   void * jresult ;
6067   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6068   Dali::Vector3 *arg2 = 0 ;
6069   Dali::Vector3 *result = 0 ;
6070
6071   arg1 = (Dali::Vector3 *)jarg1;
6072   arg2 = (Dali::Vector3 *)jarg2;
6073   if (!arg2) {
6074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6075     return 0;
6076   }
6077   {
6078     try {
6079       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6080     } catch (std::out_of_range& e) {
6081       {
6082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6083       };
6084     } catch (std::exception& e) {
6085       {
6086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6087       };
6088     } catch (Dali::DaliException e) {
6089       {
6090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6091       };
6092     } catch (...) {
6093       {
6094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6095       };
6096     }
6097   }
6098
6099   jresult = (void *)result;
6100   return jresult;
6101 }
6102
6103
6104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6105   void * jresult ;
6106   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6107   Dali::Vector3 *arg2 = 0 ;
6108   Dali::Vector3 result;
6109
6110   arg1 = (Dali::Vector3 *)jarg1;
6111   arg2 = (Dali::Vector3 *)jarg2;
6112   if (!arg2) {
6113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6114     return 0;
6115   }
6116   {
6117     try {
6118       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6119     } catch (std::out_of_range& e) {
6120       {
6121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6122       };
6123     } catch (std::exception& e) {
6124       {
6125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6126       };
6127     } catch (Dali::DaliException e) {
6128       {
6129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6130       };
6131     } catch (...) {
6132       {
6133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6134       };
6135     }
6136   }
6137
6138   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6139   return jresult;
6140 }
6141
6142
6143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6144   void * jresult ;
6145   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6146   float arg2 ;
6147   Dali::Vector3 result;
6148
6149   arg1 = (Dali::Vector3 *)jarg1;
6150   arg2 = (float)jarg2;
6151   {
6152     try {
6153       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6154     } catch (std::out_of_range& e) {
6155       {
6156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6157       };
6158     } catch (std::exception& e) {
6159       {
6160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6161       };
6162     } catch (Dali::DaliException e) {
6163       {
6164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6165       };
6166     } catch (...) {
6167       {
6168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6169       };
6170     }
6171   }
6172
6173   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6174   return jresult;
6175 }
6176
6177
6178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6179   void * jresult ;
6180   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6181   Dali::Vector3 *arg2 = 0 ;
6182   Dali::Vector3 *result = 0 ;
6183
6184   arg1 = (Dali::Vector3 *)jarg1;
6185   arg2 = (Dali::Vector3 *)jarg2;
6186   if (!arg2) {
6187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6188     return 0;
6189   }
6190   {
6191     try {
6192       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6193     } catch (std::out_of_range& e) {
6194       {
6195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6196       };
6197     } catch (std::exception& e) {
6198       {
6199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6200       };
6201     } catch (Dali::DaliException e) {
6202       {
6203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6204       };
6205     } catch (...) {
6206       {
6207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6208       };
6209     }
6210   }
6211
6212   jresult = (void *)result;
6213   return jresult;
6214 }
6215
6216
6217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6218   void * jresult ;
6219   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6220   float arg2 ;
6221   Dali::Vector3 *result = 0 ;
6222
6223   arg1 = (Dali::Vector3 *)jarg1;
6224   arg2 = (float)jarg2;
6225   {
6226     try {
6227       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6228     } catch (std::out_of_range& e) {
6229       {
6230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6231       };
6232     } catch (std::exception& e) {
6233       {
6234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6235       };
6236     } catch (Dali::DaliException e) {
6237       {
6238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6239       };
6240     } catch (...) {
6241       {
6242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6243       };
6244     }
6245   }
6246
6247   jresult = (void *)result;
6248   return jresult;
6249 }
6250
6251
6252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6253   void * jresult ;
6254   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6255   Dali::Quaternion *arg2 = 0 ;
6256   Dali::Vector3 *result = 0 ;
6257
6258   arg1 = (Dali::Vector3 *)jarg1;
6259   arg2 = (Dali::Quaternion *)jarg2;
6260   if (!arg2) {
6261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6262     return 0;
6263   }
6264   {
6265     try {
6266       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6267     } catch (std::out_of_range& e) {
6268       {
6269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6270       };
6271     } catch (std::exception& e) {
6272       {
6273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6274       };
6275     } catch (Dali::DaliException e) {
6276       {
6277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6278       };
6279     } catch (...) {
6280       {
6281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6282       };
6283     }
6284   }
6285
6286   jresult = (void *)result;
6287   return jresult;
6288 }
6289
6290
6291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6292   void * jresult ;
6293   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6294   Dali::Vector3 *arg2 = 0 ;
6295   Dali::Vector3 result;
6296
6297   arg1 = (Dali::Vector3 *)jarg1;
6298   arg2 = (Dali::Vector3 *)jarg2;
6299   if (!arg2) {
6300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6301     return 0;
6302   }
6303   {
6304     try {
6305       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6306     } catch (std::out_of_range& e) {
6307       {
6308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6309       };
6310     } catch (std::exception& e) {
6311       {
6312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6313       };
6314     } catch (Dali::DaliException e) {
6315       {
6316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6317       };
6318     } catch (...) {
6319       {
6320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6321       };
6322     }
6323   }
6324
6325   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6326   return jresult;
6327 }
6328
6329
6330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6331   void * jresult ;
6332   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6333   float arg2 ;
6334   Dali::Vector3 result;
6335
6336   arg1 = (Dali::Vector3 *)jarg1;
6337   arg2 = (float)jarg2;
6338   {
6339     try {
6340       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6341     } catch (std::out_of_range& e) {
6342       {
6343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6344       };
6345     } catch (std::exception& e) {
6346       {
6347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6348       };
6349     } catch (Dali::DaliException e) {
6350       {
6351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6352       };
6353     } catch (...) {
6354       {
6355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6356       };
6357     }
6358   }
6359
6360   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6361   return jresult;
6362 }
6363
6364
6365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6366   void * jresult ;
6367   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6368   Dali::Vector3 *arg2 = 0 ;
6369   Dali::Vector3 *result = 0 ;
6370
6371   arg1 = (Dali::Vector3 *)jarg1;
6372   arg2 = (Dali::Vector3 *)jarg2;
6373   if (!arg2) {
6374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6375     return 0;
6376   }
6377   {
6378     try {
6379       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6380     } catch (std::out_of_range& e) {
6381       {
6382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6383       };
6384     } catch (std::exception& e) {
6385       {
6386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6387       };
6388     } catch (Dali::DaliException e) {
6389       {
6390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6391       };
6392     } catch (...) {
6393       {
6394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6395       };
6396     }
6397   }
6398
6399   jresult = (void *)result;
6400   return jresult;
6401 }
6402
6403
6404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6405   void * jresult ;
6406   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6407   float arg2 ;
6408   Dali::Vector3 *result = 0 ;
6409
6410   arg1 = (Dali::Vector3 *)jarg1;
6411   arg2 = (float)jarg2;
6412   {
6413     try {
6414       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6415     } catch (std::out_of_range& e) {
6416       {
6417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6418       };
6419     } catch (std::exception& e) {
6420       {
6421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6422       };
6423     } catch (Dali::DaliException e) {
6424       {
6425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6426       };
6427     } catch (...) {
6428       {
6429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6430       };
6431     }
6432   }
6433
6434   jresult = (void *)result;
6435   return jresult;
6436 }
6437
6438
6439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6440   void * jresult ;
6441   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6442   Dali::Vector3 result;
6443
6444   arg1 = (Dali::Vector3 *)jarg1;
6445   {
6446     try {
6447       result = ((Dali::Vector3 const *)arg1)->operator -();
6448     } catch (std::out_of_range& e) {
6449       {
6450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6451       };
6452     } catch (std::exception& e) {
6453       {
6454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6455       };
6456     } catch (Dali::DaliException e) {
6457       {
6458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6459       };
6460     } catch (...) {
6461       {
6462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6463       };
6464     }
6465   }
6466
6467   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6468   return jresult;
6469 }
6470
6471
6472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6473   unsigned int jresult ;
6474   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6475   Dali::Vector3 *arg2 = 0 ;
6476   bool result;
6477
6478   arg1 = (Dali::Vector3 *)jarg1;
6479   arg2 = (Dali::Vector3 *)jarg2;
6480   if (!arg2) {
6481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6482     return 0;
6483   }
6484   {
6485     try {
6486       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6487     } catch (std::out_of_range& e) {
6488       {
6489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6490       };
6491     } catch (std::exception& e) {
6492       {
6493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6494       };
6495     } catch (Dali::DaliException e) {
6496       {
6497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6498       };
6499     } catch (...) {
6500       {
6501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6502       };
6503     }
6504   }
6505
6506   jresult = result;
6507   return jresult;
6508 }
6509
6510
6511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6512   unsigned int jresult ;
6513   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6514   Dali::Vector3 *arg2 = 0 ;
6515   bool result;
6516
6517   arg1 = (Dali::Vector3 *)jarg1;
6518   arg2 = (Dali::Vector3 *)jarg2;
6519   if (!arg2) {
6520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6521     return 0;
6522   }
6523   {
6524     try {
6525       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6526     } catch (std::out_of_range& e) {
6527       {
6528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6529       };
6530     } catch (std::exception& e) {
6531       {
6532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6533       };
6534     } catch (Dali::DaliException e) {
6535       {
6536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6537       };
6538     } catch (...) {
6539       {
6540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6541       };
6542     }
6543   }
6544
6545   jresult = result;
6546   return jresult;
6547 }
6548
6549
6550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6551   float jresult ;
6552   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6553   unsigned int arg2 ;
6554   float *result = 0 ;
6555
6556   arg1 = (Dali::Vector3 *)jarg1;
6557   arg2 = (unsigned int)jarg2;
6558   {
6559     try {
6560       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6561     } catch (std::out_of_range& e) {
6562       {
6563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6564       };
6565     } catch (std::exception& e) {
6566       {
6567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6568       };
6569     } catch (Dali::DaliException e) {
6570       {
6571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6572       };
6573     } catch (...) {
6574       {
6575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6576       };
6577     }
6578   }
6579
6580   jresult = *result;
6581   return jresult;
6582 }
6583
6584
6585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6586   float jresult ;
6587   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6588   Dali::Vector3 *arg2 = 0 ;
6589   float result;
6590
6591   arg1 = (Dali::Vector3 *)jarg1;
6592   arg2 = (Dali::Vector3 *)jarg2;
6593   if (!arg2) {
6594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6595     return 0;
6596   }
6597   {
6598     try {
6599       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6600     } catch (std::out_of_range& e) {
6601       {
6602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6603       };
6604     } catch (std::exception& e) {
6605       {
6606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6607       };
6608     } catch (Dali::DaliException e) {
6609       {
6610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6611       };
6612     } catch (...) {
6613       {
6614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6615       };
6616     }
6617   }
6618
6619   jresult = result;
6620   return jresult;
6621 }
6622
6623
6624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6625   void * jresult ;
6626   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6627   Dali::Vector3 *arg2 = 0 ;
6628   Dali::Vector3 result;
6629
6630   arg1 = (Dali::Vector3 *)jarg1;
6631   arg2 = (Dali::Vector3 *)jarg2;
6632   if (!arg2) {
6633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6634     return 0;
6635   }
6636   {
6637     try {
6638       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6639     } catch (std::out_of_range& e) {
6640       {
6641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6642       };
6643     } catch (std::exception& e) {
6644       {
6645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6646       };
6647     } catch (Dali::DaliException e) {
6648       {
6649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6650       };
6651     } catch (...) {
6652       {
6653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6654       };
6655     }
6656   }
6657
6658   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6659   return jresult;
6660 }
6661
6662
6663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6664   float jresult ;
6665   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6666   float result;
6667
6668   arg1 = (Dali::Vector3 *)jarg1;
6669   {
6670     try {
6671       result = (float)((Dali::Vector3 const *)arg1)->Length();
6672     } catch (std::out_of_range& e) {
6673       {
6674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6675       };
6676     } catch (std::exception& e) {
6677       {
6678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6679       };
6680     } catch (Dali::DaliException e) {
6681       {
6682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6683       };
6684     } catch (...) {
6685       {
6686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6687       };
6688     }
6689   }
6690
6691   jresult = result;
6692   return jresult;
6693 }
6694
6695
6696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6697   float jresult ;
6698   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6699   float result;
6700
6701   arg1 = (Dali::Vector3 *)jarg1;
6702   {
6703     try {
6704       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6705     } catch (std::out_of_range& e) {
6706       {
6707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6708       };
6709     } catch (std::exception& e) {
6710       {
6711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6712       };
6713     } catch (Dali::DaliException e) {
6714       {
6715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6716       };
6717     } catch (...) {
6718       {
6719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6720       };
6721     }
6722   }
6723
6724   jresult = result;
6725   return jresult;
6726 }
6727
6728
6729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6730   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6731
6732   arg1 = (Dali::Vector3 *)jarg1;
6733   {
6734     try {
6735       (arg1)->Normalize();
6736     } catch (std::out_of_range& e) {
6737       {
6738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6739       };
6740     } catch (std::exception& e) {
6741       {
6742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6743       };
6744     } catch (Dali::DaliException e) {
6745       {
6746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6747       };
6748     } catch (...) {
6749       {
6750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6751       };
6752     }
6753   }
6754
6755 }
6756
6757
6758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6759   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6760   Dali::Vector3 *arg2 = 0 ;
6761   Dali::Vector3 *arg3 = 0 ;
6762
6763   arg1 = (Dali::Vector3 *)jarg1;
6764   arg2 = (Dali::Vector3 *)jarg2;
6765   if (!arg2) {
6766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6767     return ;
6768   }
6769   arg3 = (Dali::Vector3 *)jarg3;
6770   if (!arg3) {
6771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6772     return ;
6773   }
6774   {
6775     try {
6776       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6777     } catch (std::out_of_range& e) {
6778       {
6779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6780       };
6781     } catch (std::exception& e) {
6782       {
6783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6784       };
6785     } catch (Dali::DaliException e) {
6786       {
6787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6788       };
6789     } catch (...) {
6790       {
6791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6792       };
6793     }
6794   }
6795
6796 }
6797
6798
6799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6800   void * jresult ;
6801   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6802   float *result = 0 ;
6803
6804   arg1 = (Dali::Vector3 *)jarg1;
6805   {
6806     try {
6807       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6808     } catch (std::out_of_range& e) {
6809       {
6810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6811       };
6812     } catch (std::exception& e) {
6813       {
6814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6815       };
6816     } catch (Dali::DaliException e) {
6817       {
6818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6819       };
6820     } catch (...) {
6821       {
6822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6823       };
6824     }
6825   }
6826
6827   jresult = (void *)result;
6828   return jresult;
6829 }
6830
6831
6832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6833   void * jresult ;
6834   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6835   Dali::Vector2 *result = 0 ;
6836
6837   arg1 = (Dali::Vector3 *)jarg1;
6838   {
6839     try {
6840       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6841     } catch (std::out_of_range& e) {
6842       {
6843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6844       };
6845     } catch (std::exception& e) {
6846       {
6847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6848       };
6849     } catch (Dali::DaliException e) {
6850       {
6851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6852       };
6853     } catch (...) {
6854       {
6855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6856       };
6857     }
6858   }
6859
6860   jresult = (void *)result;
6861   return jresult;
6862 }
6863
6864
6865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6866   void * jresult ;
6867   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6868   Dali::Vector2 *result = 0 ;
6869
6870   arg1 = (Dali::Vector3 *)jarg1;
6871   {
6872     try {
6873       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6874     } catch (std::out_of_range& e) {
6875       {
6876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6877       };
6878     } catch (std::exception& e) {
6879       {
6880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6881       };
6882     } catch (Dali::DaliException e) {
6883       {
6884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6885       };
6886     } catch (...) {
6887       {
6888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6889       };
6890     }
6891   }
6892
6893   jresult = (void *)result;
6894   return jresult;
6895 }
6896
6897
6898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6899   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6900   float arg2 ;
6901
6902   arg1 = (Dali::Vector3 *)jarg1;
6903   arg2 = (float)jarg2;
6904   if (arg1) (arg1)->x = arg2;
6905 }
6906
6907
6908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6909   float jresult ;
6910   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6911   float result;
6912
6913   arg1 = (Dali::Vector3 *)jarg1;
6914   result = (float) ((arg1)->x);
6915   jresult = result;
6916   return jresult;
6917 }
6918
6919
6920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6922   float arg2 ;
6923
6924   arg1 = (Dali::Vector3 *)jarg1;
6925   arg2 = (float)jarg2;
6926   if (arg1) (arg1)->width = arg2;
6927 }
6928
6929
6930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6931   float jresult ;
6932   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6933   float result;
6934
6935   arg1 = (Dali::Vector3 *)jarg1;
6936   result = (float) ((arg1)->width);
6937   jresult = result;
6938   return jresult;
6939 }
6940
6941
6942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6944   float arg2 ;
6945
6946   arg1 = (Dali::Vector3 *)jarg1;
6947   arg2 = (float)jarg2;
6948   if (arg1) (arg1)->r = arg2;
6949 }
6950
6951
6952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6953   float jresult ;
6954   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6955   float result;
6956
6957   arg1 = (Dali::Vector3 *)jarg1;
6958   result = (float) ((arg1)->r);
6959   jresult = result;
6960   return jresult;
6961 }
6962
6963
6964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6965   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6966   float arg2 ;
6967
6968   arg1 = (Dali::Vector3 *)jarg1;
6969   arg2 = (float)jarg2;
6970   if (arg1) (arg1)->y = arg2;
6971 }
6972
6973
6974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6975   float jresult ;
6976   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6977   float result;
6978
6979   arg1 = (Dali::Vector3 *)jarg1;
6980   result = (float) ((arg1)->y);
6981   jresult = result;
6982   return jresult;
6983 }
6984
6985
6986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6987   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6988   float arg2 ;
6989
6990   arg1 = (Dali::Vector3 *)jarg1;
6991   arg2 = (float)jarg2;
6992   if (arg1) (arg1)->height = arg2;
6993 }
6994
6995
6996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6997   float jresult ;
6998   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6999   float result;
7000
7001   arg1 = (Dali::Vector3 *)jarg1;
7002   result = (float) ((arg1)->height);
7003   jresult = result;
7004   return jresult;
7005 }
7006
7007
7008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7009   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7010   float arg2 ;
7011
7012   arg1 = (Dali::Vector3 *)jarg1;
7013   arg2 = (float)jarg2;
7014   if (arg1) (arg1)->g = arg2;
7015 }
7016
7017
7018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7019   float jresult ;
7020   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7021   float result;
7022
7023   arg1 = (Dali::Vector3 *)jarg1;
7024   result = (float) ((arg1)->g);
7025   jresult = result;
7026   return jresult;
7027 }
7028
7029
7030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7032   float arg2 ;
7033
7034   arg1 = (Dali::Vector3 *)jarg1;
7035   arg2 = (float)jarg2;
7036   if (arg1) (arg1)->z = arg2;
7037 }
7038
7039
7040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7041   float jresult ;
7042   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7043   float result;
7044
7045   arg1 = (Dali::Vector3 *)jarg1;
7046   result = (float) ((arg1)->z);
7047   jresult = result;
7048   return jresult;
7049 }
7050
7051
7052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7053   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7054   float arg2 ;
7055
7056   arg1 = (Dali::Vector3 *)jarg1;
7057   arg2 = (float)jarg2;
7058   if (arg1) (arg1)->depth = arg2;
7059 }
7060
7061
7062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7063   float jresult ;
7064   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7065   float result;
7066
7067   arg1 = (Dali::Vector3 *)jarg1;
7068   result = (float) ((arg1)->depth);
7069   jresult = result;
7070   return jresult;
7071 }
7072
7073
7074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7075   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7076   float arg2 ;
7077
7078   arg1 = (Dali::Vector3 *)jarg1;
7079   arg2 = (float)jarg2;
7080   if (arg1) (arg1)->b = arg2;
7081 }
7082
7083
7084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7085   float jresult ;
7086   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7087   float result;
7088
7089   arg1 = (Dali::Vector3 *)jarg1;
7090   result = (float) ((arg1)->b);
7091   jresult = result;
7092   return jresult;
7093 }
7094
7095
7096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7097   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7098
7099   arg1 = (Dali::Vector3 *)jarg1;
7100   {
7101     try {
7102       delete arg1;
7103     } catch (std::out_of_range& e) {
7104       {
7105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7106       };
7107     } catch (std::exception& e) {
7108       {
7109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7110       };
7111     } catch (Dali::DaliException e) {
7112       {
7113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7114       };
7115     } catch (...) {
7116       {
7117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7118       };
7119     }
7120   }
7121
7122 }
7123
7124
7125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7126   void * jresult ;
7127   Dali::Vector3 *arg1 = 0 ;
7128   Dali::Vector3 *arg2 = 0 ;
7129   Dali::Vector3 result;
7130
7131   arg1 = (Dali::Vector3 *)jarg1;
7132   if (!arg1) {
7133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7134     return 0;
7135   }
7136   arg2 = (Dali::Vector3 *)jarg2;
7137   if (!arg2) {
7138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7139     return 0;
7140   }
7141   {
7142     try {
7143       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7144     } catch (std::out_of_range& e) {
7145       {
7146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7147       };
7148     } catch (std::exception& e) {
7149       {
7150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7151       };
7152     } catch (Dali::DaliException e) {
7153       {
7154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7155       };
7156     } catch (...) {
7157       {
7158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7159       };
7160     }
7161   }
7162
7163   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7164   return jresult;
7165 }
7166
7167
7168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7169   void * jresult ;
7170   Dali::Vector3 *arg1 = 0 ;
7171   Dali::Vector3 *arg2 = 0 ;
7172   Dali::Vector3 result;
7173
7174   arg1 = (Dali::Vector3 *)jarg1;
7175   if (!arg1) {
7176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7177     return 0;
7178   }
7179   arg2 = (Dali::Vector3 *)jarg2;
7180   if (!arg2) {
7181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7182     return 0;
7183   }
7184   {
7185     try {
7186       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7187     } catch (std::out_of_range& e) {
7188       {
7189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7190       };
7191     } catch (std::exception& e) {
7192       {
7193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7194       };
7195     } catch (Dali::DaliException e) {
7196       {
7197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7198       };
7199     } catch (...) {
7200       {
7201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7202       };
7203     }
7204   }
7205
7206   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7207   return jresult;
7208 }
7209
7210
7211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7212   void * jresult ;
7213   Dali::Vector3 *arg1 = 0 ;
7214   float *arg2 = 0 ;
7215   float *arg3 = 0 ;
7216   float temp2 ;
7217   float temp3 ;
7218   Dali::Vector3 result;
7219
7220   arg1 = (Dali::Vector3 *)jarg1;
7221   if (!arg1) {
7222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7223     return 0;
7224   }
7225   temp2 = (float)jarg2;
7226   arg2 = &temp2;
7227   temp3 = (float)jarg3;
7228   arg3 = &temp3;
7229   {
7230     try {
7231       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7232     } catch (std::out_of_range& e) {
7233       {
7234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7235       };
7236     } catch (std::exception& e) {
7237       {
7238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7239       };
7240     } catch (Dali::DaliException e) {
7241       {
7242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7243       };
7244     } catch (...) {
7245       {
7246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7247       };
7248     }
7249   }
7250
7251   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7252   return jresult;
7253 }
7254
7255
7256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7257   void * jresult ;
7258   Dali::Vector4 *result = 0 ;
7259
7260   {
7261     try {
7262       result = (Dali::Vector4 *)new Dali::Vector4();
7263     } catch (std::out_of_range& e) {
7264       {
7265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7266       };
7267     } catch (std::exception& e) {
7268       {
7269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7270       };
7271     } catch (Dali::DaliException e) {
7272       {
7273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7274       };
7275     } catch (...) {
7276       {
7277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7278       };
7279     }
7280   }
7281
7282   jresult = (void *)result;
7283   return jresult;
7284 }
7285
7286
7287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7288   void * jresult ;
7289   float arg1 ;
7290   float arg2 ;
7291   float arg3 ;
7292   float arg4 ;
7293   Dali::Vector4 *result = 0 ;
7294
7295   arg1 = (float)jarg1;
7296   arg2 = (float)jarg2;
7297   arg3 = (float)jarg3;
7298   arg4 = (float)jarg4;
7299   {
7300     try {
7301       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7302     } catch (std::out_of_range& e) {
7303       {
7304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7305       };
7306     } catch (std::exception& e) {
7307       {
7308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7309       };
7310     } catch (Dali::DaliException e) {
7311       {
7312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7313       };
7314     } catch (...) {
7315       {
7316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7317       };
7318     }
7319   }
7320
7321   jresult = (void *)result;
7322   return jresult;
7323 }
7324
7325
7326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7327   void * jresult ;
7328   float *arg1 = (float *) 0 ;
7329   Dali::Vector4 *result = 0 ;
7330
7331   arg1 = jarg1;
7332   {
7333     try {
7334       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7335     } catch (std::out_of_range& e) {
7336       {
7337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7338       };
7339     } catch (std::exception& e) {
7340       {
7341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7342       };
7343     } catch (Dali::DaliException e) {
7344       {
7345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7346       };
7347     } catch (...) {
7348       {
7349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7350       };
7351     }
7352   }
7353
7354   jresult = (void *)result;
7355
7356
7357   return jresult;
7358 }
7359
7360
7361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7362   void * jresult ;
7363   Dali::Vector2 *arg1 = 0 ;
7364   Dali::Vector4 *result = 0 ;
7365
7366   arg1 = (Dali::Vector2 *)jarg1;
7367   if (!arg1) {
7368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7369     return 0;
7370   }
7371   {
7372     try {
7373       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7374     } catch (std::out_of_range& e) {
7375       {
7376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7377       };
7378     } catch (std::exception& e) {
7379       {
7380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7381       };
7382     } catch (Dali::DaliException e) {
7383       {
7384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7385       };
7386     } catch (...) {
7387       {
7388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7389       };
7390     }
7391   }
7392
7393   jresult = (void *)result;
7394   return jresult;
7395 }
7396
7397
7398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7399   void * jresult ;
7400   Dali::Vector3 *arg1 = 0 ;
7401   Dali::Vector4 *result = 0 ;
7402
7403   arg1 = (Dali::Vector3 *)jarg1;
7404   if (!arg1) {
7405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7406     return 0;
7407   }
7408   {
7409     try {
7410       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7411     } catch (std::out_of_range& e) {
7412       {
7413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7414       };
7415     } catch (std::exception& e) {
7416       {
7417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7418       };
7419     } catch (Dali::DaliException e) {
7420       {
7421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7422       };
7423     } catch (...) {
7424       {
7425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7426       };
7427     }
7428   }
7429
7430   jresult = (void *)result;
7431   return jresult;
7432 }
7433
7434
7435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7436   void * jresult ;
7437   Dali::Vector4 *result = 0 ;
7438
7439   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7440   jresult = (void *)result;
7441   return jresult;
7442 }
7443
7444
7445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7446   void * jresult ;
7447   Dali::Vector4 *result = 0 ;
7448
7449   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7450   jresult = (void *)result;
7451   return jresult;
7452 }
7453
7454
7455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7456   void * jresult ;
7457   Dali::Vector4 *result = 0 ;
7458
7459   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7460   jresult = (void *)result;
7461   return jresult;
7462 }
7463
7464
7465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7466   void * jresult ;
7467   Dali::Vector4 *result = 0 ;
7468
7469   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7470   jresult = (void *)result;
7471   return jresult;
7472 }
7473
7474
7475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7476   void * jresult ;
7477   Dali::Vector4 *result = 0 ;
7478
7479   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7480   jresult = (void *)result;
7481   return jresult;
7482 }
7483
7484
7485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7486   void * jresult ;
7487   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7488   float *arg2 = (float *) 0 ;
7489   Dali::Vector4 *result = 0 ;
7490
7491   arg1 = (Dali::Vector4 *)jarg1;
7492   arg2 = jarg2;
7493   {
7494     try {
7495       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7496     } catch (std::out_of_range& e) {
7497       {
7498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7499       };
7500     } catch (std::exception& e) {
7501       {
7502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7503       };
7504     } catch (Dali::DaliException e) {
7505       {
7506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7507       };
7508     } catch (...) {
7509       {
7510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7511       };
7512     }
7513   }
7514
7515   jresult = (void *)result;
7516
7517
7518   return jresult;
7519 }
7520
7521
7522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7523   void * jresult ;
7524   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7525   Dali::Vector2 *arg2 = 0 ;
7526   Dali::Vector4 *result = 0 ;
7527
7528   arg1 = (Dali::Vector4 *)jarg1;
7529   arg2 = (Dali::Vector2 *)jarg2;
7530   if (!arg2) {
7531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7532     return 0;
7533   }
7534   {
7535     try {
7536       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7537     } catch (std::out_of_range& e) {
7538       {
7539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7540       };
7541     } catch (std::exception& e) {
7542       {
7543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7544       };
7545     } catch (Dali::DaliException e) {
7546       {
7547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7548       };
7549     } catch (...) {
7550       {
7551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7552       };
7553     }
7554   }
7555
7556   jresult = (void *)result;
7557   return jresult;
7558 }
7559
7560
7561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7562   void * jresult ;
7563   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7564   Dali::Vector3 *arg2 = 0 ;
7565   Dali::Vector4 *result = 0 ;
7566
7567   arg1 = (Dali::Vector4 *)jarg1;
7568   arg2 = (Dali::Vector3 *)jarg2;
7569   if (!arg2) {
7570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7571     return 0;
7572   }
7573   {
7574     try {
7575       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7576     } catch (std::out_of_range& e) {
7577       {
7578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7579       };
7580     } catch (std::exception& e) {
7581       {
7582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7583       };
7584     } catch (Dali::DaliException e) {
7585       {
7586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7587       };
7588     } catch (...) {
7589       {
7590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7591       };
7592     }
7593   }
7594
7595   jresult = (void *)result;
7596   return jresult;
7597 }
7598
7599
7600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7601   void * jresult ;
7602   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7603   Dali::Vector4 *arg2 = 0 ;
7604   Dali::Vector4 result;
7605
7606   arg1 = (Dali::Vector4 *)jarg1;
7607   arg2 = (Dali::Vector4 *)jarg2;
7608   if (!arg2) {
7609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7610     return 0;
7611   }
7612   {
7613     try {
7614       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7615     } catch (std::out_of_range& e) {
7616       {
7617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7618       };
7619     } catch (std::exception& e) {
7620       {
7621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7622       };
7623     } catch (Dali::DaliException e) {
7624       {
7625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7626       };
7627     } catch (...) {
7628       {
7629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7630       };
7631     }
7632   }
7633
7634   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7635   return jresult;
7636 }
7637
7638
7639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7640   void * jresult ;
7641   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7642   Dali::Vector4 *arg2 = 0 ;
7643   Dali::Vector4 *result = 0 ;
7644
7645   arg1 = (Dali::Vector4 *)jarg1;
7646   arg2 = (Dali::Vector4 *)jarg2;
7647   if (!arg2) {
7648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7649     return 0;
7650   }
7651   {
7652     try {
7653       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7654     } catch (std::out_of_range& e) {
7655       {
7656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7657       };
7658     } catch (std::exception& e) {
7659       {
7660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7661       };
7662     } catch (Dali::DaliException e) {
7663       {
7664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7665       };
7666     } catch (...) {
7667       {
7668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7669       };
7670     }
7671   }
7672
7673   jresult = (void *)result;
7674   return jresult;
7675 }
7676
7677
7678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7679   void * jresult ;
7680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7681   Dali::Vector4 *arg2 = 0 ;
7682   Dali::Vector4 result;
7683
7684   arg1 = (Dali::Vector4 *)jarg1;
7685   arg2 = (Dali::Vector4 *)jarg2;
7686   if (!arg2) {
7687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7688     return 0;
7689   }
7690   {
7691     try {
7692       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7693     } catch (std::out_of_range& e) {
7694       {
7695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7696       };
7697     } catch (std::exception& e) {
7698       {
7699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7700       };
7701     } catch (Dali::DaliException e) {
7702       {
7703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7704       };
7705     } catch (...) {
7706       {
7707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7708       };
7709     }
7710   }
7711
7712   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7713   return jresult;
7714 }
7715
7716
7717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7718   void * jresult ;
7719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7720   Dali::Vector4 *arg2 = 0 ;
7721   Dali::Vector4 *result = 0 ;
7722
7723   arg1 = (Dali::Vector4 *)jarg1;
7724   arg2 = (Dali::Vector4 *)jarg2;
7725   if (!arg2) {
7726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7727     return 0;
7728   }
7729   {
7730     try {
7731       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7732     } catch (std::out_of_range& e) {
7733       {
7734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7735       };
7736     } catch (std::exception& e) {
7737       {
7738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7739       };
7740     } catch (Dali::DaliException e) {
7741       {
7742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7743       };
7744     } catch (...) {
7745       {
7746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7747       };
7748     }
7749   }
7750
7751   jresult = (void *)result;
7752   return jresult;
7753 }
7754
7755
7756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7757   void * jresult ;
7758   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7759   Dali::Vector4 *arg2 = 0 ;
7760   Dali::Vector4 result;
7761
7762   arg1 = (Dali::Vector4 *)jarg1;
7763   arg2 = (Dali::Vector4 *)jarg2;
7764   if (!arg2) {
7765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7766     return 0;
7767   }
7768   {
7769     try {
7770       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7771     } catch (std::out_of_range& e) {
7772       {
7773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7774       };
7775     } catch (std::exception& e) {
7776       {
7777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7778       };
7779     } catch (Dali::DaliException e) {
7780       {
7781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7782       };
7783     } catch (...) {
7784       {
7785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7786       };
7787     }
7788   }
7789
7790   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7791   return jresult;
7792 }
7793
7794
7795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7796   void * jresult ;
7797   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7798   float arg2 ;
7799   Dali::Vector4 result;
7800
7801   arg1 = (Dali::Vector4 *)jarg1;
7802   arg2 = (float)jarg2;
7803   {
7804     try {
7805       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7806     } catch (std::out_of_range& e) {
7807       {
7808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7809       };
7810     } catch (std::exception& e) {
7811       {
7812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7813       };
7814     } catch (Dali::DaliException e) {
7815       {
7816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7817       };
7818     } catch (...) {
7819       {
7820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7821       };
7822     }
7823   }
7824
7825   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7826   return jresult;
7827 }
7828
7829
7830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7831   void * jresult ;
7832   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7833   Dali::Vector4 *arg2 = 0 ;
7834   Dali::Vector4 *result = 0 ;
7835
7836   arg1 = (Dali::Vector4 *)jarg1;
7837   arg2 = (Dali::Vector4 *)jarg2;
7838   if (!arg2) {
7839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7840     return 0;
7841   }
7842   {
7843     try {
7844       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7845     } catch (std::out_of_range& e) {
7846       {
7847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7848       };
7849     } catch (std::exception& e) {
7850       {
7851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7852       };
7853     } catch (Dali::DaliException e) {
7854       {
7855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7856       };
7857     } catch (...) {
7858       {
7859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7860       };
7861     }
7862   }
7863
7864   jresult = (void *)result;
7865   return jresult;
7866 }
7867
7868
7869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7870   void * jresult ;
7871   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7872   float arg2 ;
7873   Dali::Vector4 *result = 0 ;
7874
7875   arg1 = (Dali::Vector4 *)jarg1;
7876   arg2 = (float)jarg2;
7877   {
7878     try {
7879       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7880     } catch (std::out_of_range& e) {
7881       {
7882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7883       };
7884     } catch (std::exception& e) {
7885       {
7886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7887       };
7888     } catch (Dali::DaliException e) {
7889       {
7890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7891       };
7892     } catch (...) {
7893       {
7894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7895       };
7896     }
7897   }
7898
7899   jresult = (void *)result;
7900   return jresult;
7901 }
7902
7903
7904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7905   void * jresult ;
7906   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7907   Dali::Vector4 *arg2 = 0 ;
7908   Dali::Vector4 result;
7909
7910   arg1 = (Dali::Vector4 *)jarg1;
7911   arg2 = (Dali::Vector4 *)jarg2;
7912   if (!arg2) {
7913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7914     return 0;
7915   }
7916   {
7917     try {
7918       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7919     } catch (std::out_of_range& e) {
7920       {
7921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7922       };
7923     } catch (std::exception& e) {
7924       {
7925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7926       };
7927     } catch (Dali::DaliException e) {
7928       {
7929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7930       };
7931     } catch (...) {
7932       {
7933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7934       };
7935     }
7936   }
7937
7938   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7939   return jresult;
7940 }
7941
7942
7943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7944   void * jresult ;
7945   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7946   float arg2 ;
7947   Dali::Vector4 result;
7948
7949   arg1 = (Dali::Vector4 *)jarg1;
7950   arg2 = (float)jarg2;
7951   {
7952     try {
7953       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7954     } catch (std::out_of_range& e) {
7955       {
7956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7957       };
7958     } catch (std::exception& e) {
7959       {
7960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7961       };
7962     } catch (Dali::DaliException e) {
7963       {
7964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7965       };
7966     } catch (...) {
7967       {
7968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7969       };
7970     }
7971   }
7972
7973   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7974   return jresult;
7975 }
7976
7977
7978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7979   void * jresult ;
7980   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7981   Dali::Vector4 *arg2 = 0 ;
7982   Dali::Vector4 *result = 0 ;
7983
7984   arg1 = (Dali::Vector4 *)jarg1;
7985   arg2 = (Dali::Vector4 *)jarg2;
7986   if (!arg2) {
7987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7988     return 0;
7989   }
7990   {
7991     try {
7992       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7993     } catch (std::out_of_range& e) {
7994       {
7995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7996       };
7997     } catch (std::exception& e) {
7998       {
7999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8000       };
8001     } catch (Dali::DaliException e) {
8002       {
8003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8004       };
8005     } catch (...) {
8006       {
8007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8008       };
8009     }
8010   }
8011
8012   jresult = (void *)result;
8013   return jresult;
8014 }
8015
8016
8017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8018   void * jresult ;
8019   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8020   float arg2 ;
8021   Dali::Vector4 *result = 0 ;
8022
8023   arg1 = (Dali::Vector4 *)jarg1;
8024   arg2 = (float)jarg2;
8025   {
8026     try {
8027       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8028     } catch (std::out_of_range& e) {
8029       {
8030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8031       };
8032     } catch (std::exception& e) {
8033       {
8034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8035       };
8036     } catch (Dali::DaliException e) {
8037       {
8038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8039       };
8040     } catch (...) {
8041       {
8042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8043       };
8044     }
8045   }
8046
8047   jresult = (void *)result;
8048   return jresult;
8049 }
8050
8051
8052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8053   void * jresult ;
8054   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8055   Dali::Vector4 result;
8056
8057   arg1 = (Dali::Vector4 *)jarg1;
8058   {
8059     try {
8060       result = ((Dali::Vector4 const *)arg1)->operator -();
8061     } catch (std::out_of_range& e) {
8062       {
8063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8064       };
8065     } catch (std::exception& e) {
8066       {
8067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8068       };
8069     } catch (Dali::DaliException e) {
8070       {
8071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8072       };
8073     } catch (...) {
8074       {
8075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8076       };
8077     }
8078   }
8079
8080   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8081   return jresult;
8082 }
8083
8084
8085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8086   unsigned int jresult ;
8087   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8088   Dali::Vector4 *arg2 = 0 ;
8089   bool result;
8090
8091   arg1 = (Dali::Vector4 *)jarg1;
8092   arg2 = (Dali::Vector4 *)jarg2;
8093   if (!arg2) {
8094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8095     return 0;
8096   }
8097   {
8098     try {
8099       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8100     } catch (std::out_of_range& e) {
8101       {
8102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8103       };
8104     } catch (std::exception& e) {
8105       {
8106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8107       };
8108     } catch (Dali::DaliException e) {
8109       {
8110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8111       };
8112     } catch (...) {
8113       {
8114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8115       };
8116     }
8117   }
8118
8119   jresult = result;
8120   return jresult;
8121 }
8122
8123
8124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8125   unsigned int jresult ;
8126   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8127   Dali::Vector4 *arg2 = 0 ;
8128   bool result;
8129
8130   arg1 = (Dali::Vector4 *)jarg1;
8131   arg2 = (Dali::Vector4 *)jarg2;
8132   if (!arg2) {
8133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8134     return 0;
8135   }
8136   {
8137     try {
8138       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8139     } catch (std::out_of_range& e) {
8140       {
8141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8142       };
8143     } catch (std::exception& e) {
8144       {
8145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8146       };
8147     } catch (Dali::DaliException e) {
8148       {
8149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8150       };
8151     } catch (...) {
8152       {
8153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8154       };
8155     }
8156   }
8157
8158   jresult = result;
8159   return jresult;
8160 }
8161
8162
8163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8164   float jresult ;
8165   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8166   unsigned int arg2 ;
8167   float *result = 0 ;
8168
8169   arg1 = (Dali::Vector4 *)jarg1;
8170   arg2 = (unsigned int)jarg2;
8171   {
8172     try {
8173       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8174     } catch (std::out_of_range& e) {
8175       {
8176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8177       };
8178     } catch (std::exception& e) {
8179       {
8180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8181       };
8182     } catch (Dali::DaliException e) {
8183       {
8184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8185       };
8186     } catch (...) {
8187       {
8188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8189       };
8190     }
8191   }
8192
8193   jresult = *result;
8194   return jresult;
8195 }
8196
8197
8198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8199   float jresult ;
8200   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8201   Dali::Vector3 *arg2 = 0 ;
8202   float result;
8203
8204   arg1 = (Dali::Vector4 *)jarg1;
8205   arg2 = (Dali::Vector3 *)jarg2;
8206   if (!arg2) {
8207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8208     return 0;
8209   }
8210   {
8211     try {
8212       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8213     } catch (std::out_of_range& e) {
8214       {
8215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8216       };
8217     } catch (std::exception& e) {
8218       {
8219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8220       };
8221     } catch (Dali::DaliException e) {
8222       {
8223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8224       };
8225     } catch (...) {
8226       {
8227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8228       };
8229     }
8230   }
8231
8232   jresult = result;
8233   return jresult;
8234 }
8235
8236
8237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8238   float jresult ;
8239   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8240   Dali::Vector4 *arg2 = 0 ;
8241   float result;
8242
8243   arg1 = (Dali::Vector4 *)jarg1;
8244   arg2 = (Dali::Vector4 *)jarg2;
8245   if (!arg2) {
8246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8247     return 0;
8248   }
8249   {
8250     try {
8251       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8252     } catch (std::out_of_range& e) {
8253       {
8254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8255       };
8256     } catch (std::exception& e) {
8257       {
8258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8259       };
8260     } catch (Dali::DaliException e) {
8261       {
8262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8263       };
8264     } catch (...) {
8265       {
8266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8267       };
8268     }
8269   }
8270
8271   jresult = result;
8272   return jresult;
8273 }
8274
8275
8276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8277   float jresult ;
8278   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8279   Dali::Vector4 *arg2 = 0 ;
8280   float result;
8281
8282   arg1 = (Dali::Vector4 *)jarg1;
8283   arg2 = (Dali::Vector4 *)jarg2;
8284   if (!arg2) {
8285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8286     return 0;
8287   }
8288   {
8289     try {
8290       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8291     } catch (std::out_of_range& e) {
8292       {
8293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8294       };
8295     } catch (std::exception& e) {
8296       {
8297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8298       };
8299     } catch (Dali::DaliException e) {
8300       {
8301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8302       };
8303     } catch (...) {
8304       {
8305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8306       };
8307     }
8308   }
8309
8310   jresult = result;
8311   return jresult;
8312 }
8313
8314
8315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8316   void * jresult ;
8317   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8318   Dali::Vector4 *arg2 = 0 ;
8319   Dali::Vector4 result;
8320
8321   arg1 = (Dali::Vector4 *)jarg1;
8322   arg2 = (Dali::Vector4 *)jarg2;
8323   if (!arg2) {
8324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8325     return 0;
8326   }
8327   {
8328     try {
8329       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8330     } catch (std::out_of_range& e) {
8331       {
8332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8333       };
8334     } catch (std::exception& e) {
8335       {
8336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8337       };
8338     } catch (Dali::DaliException e) {
8339       {
8340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8341       };
8342     } catch (...) {
8343       {
8344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8345       };
8346     }
8347   }
8348
8349   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8350   return jresult;
8351 }
8352
8353
8354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8355   float jresult ;
8356   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8357   float result;
8358
8359   arg1 = (Dali::Vector4 *)jarg1;
8360   {
8361     try {
8362       result = (float)((Dali::Vector4 const *)arg1)->Length();
8363     } catch (std::out_of_range& e) {
8364       {
8365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8366       };
8367     } catch (std::exception& e) {
8368       {
8369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8370       };
8371     } catch (Dali::DaliException e) {
8372       {
8373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8374       };
8375     } catch (...) {
8376       {
8377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8378       };
8379     }
8380   }
8381
8382   jresult = result;
8383   return jresult;
8384 }
8385
8386
8387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8388   float jresult ;
8389   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8390   float result;
8391
8392   arg1 = (Dali::Vector4 *)jarg1;
8393   {
8394     try {
8395       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8396     } catch (std::out_of_range& e) {
8397       {
8398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8399       };
8400     } catch (std::exception& e) {
8401       {
8402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8403       };
8404     } catch (Dali::DaliException e) {
8405       {
8406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8407       };
8408     } catch (...) {
8409       {
8410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8411       };
8412     }
8413   }
8414
8415   jresult = result;
8416   return jresult;
8417 }
8418
8419
8420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8421   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8422
8423   arg1 = (Dali::Vector4 *)jarg1;
8424   {
8425     try {
8426       (arg1)->Normalize();
8427     } catch (std::out_of_range& e) {
8428       {
8429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8430       };
8431     } catch (std::exception& e) {
8432       {
8433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8434       };
8435     } catch (Dali::DaliException e) {
8436       {
8437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8438       };
8439     } catch (...) {
8440       {
8441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8442       };
8443     }
8444   }
8445
8446 }
8447
8448
8449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8450   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8451   Dali::Vector4 *arg2 = 0 ;
8452   Dali::Vector4 *arg3 = 0 ;
8453
8454   arg1 = (Dali::Vector4 *)jarg1;
8455   arg2 = (Dali::Vector4 *)jarg2;
8456   if (!arg2) {
8457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8458     return ;
8459   }
8460   arg3 = (Dali::Vector4 *)jarg3;
8461   if (!arg3) {
8462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8463     return ;
8464   }
8465   {
8466     try {
8467       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8468     } catch (std::out_of_range& e) {
8469       {
8470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8471       };
8472     } catch (std::exception& e) {
8473       {
8474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8475       };
8476     } catch (Dali::DaliException e) {
8477       {
8478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8479       };
8480     } catch (...) {
8481       {
8482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8483       };
8484     }
8485   }
8486
8487 }
8488
8489
8490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8491   void * jresult ;
8492   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8493   float *result = 0 ;
8494
8495   arg1 = (Dali::Vector4 *)jarg1;
8496   {
8497     try {
8498       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8499     } catch (std::out_of_range& e) {
8500       {
8501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8502       };
8503     } catch (std::exception& e) {
8504       {
8505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8506       };
8507     } catch (Dali::DaliException e) {
8508       {
8509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8510       };
8511     } catch (...) {
8512       {
8513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8514       };
8515     }
8516   }
8517
8518   jresult = (void *)result;
8519   return jresult;
8520 }
8521
8522
8523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8524   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8525   float arg2 ;
8526
8527   arg1 = (Dali::Vector4 *)jarg1;
8528   arg2 = (float)jarg2;
8529   if (arg1) (arg1)->x = arg2;
8530 }
8531
8532
8533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8534   float jresult ;
8535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8536   float result;
8537
8538   arg1 = (Dali::Vector4 *)jarg1;
8539   result = (float) ((arg1)->x);
8540   jresult = result;
8541   return jresult;
8542 }
8543
8544
8545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8546   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8547   float arg2 ;
8548
8549   arg1 = (Dali::Vector4 *)jarg1;
8550   arg2 = (float)jarg2;
8551   if (arg1) (arg1)->r = arg2;
8552 }
8553
8554
8555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8556   float jresult ;
8557   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8558   float result;
8559
8560   arg1 = (Dali::Vector4 *)jarg1;
8561   result = (float) ((arg1)->r);
8562   jresult = result;
8563   return jresult;
8564 }
8565
8566
8567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8569   float arg2 ;
8570
8571   arg1 = (Dali::Vector4 *)jarg1;
8572   arg2 = (float)jarg2;
8573   if (arg1) (arg1)->s = arg2;
8574 }
8575
8576
8577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8578   float jresult ;
8579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8580   float result;
8581
8582   arg1 = (Dali::Vector4 *)jarg1;
8583   result = (float) ((arg1)->s);
8584   jresult = result;
8585   return jresult;
8586 }
8587
8588
8589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8591   float arg2 ;
8592
8593   arg1 = (Dali::Vector4 *)jarg1;
8594   arg2 = (float)jarg2;
8595   if (arg1) (arg1)->y = arg2;
8596 }
8597
8598
8599 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8600   float jresult ;
8601   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8602   float result;
8603
8604   arg1 = (Dali::Vector4 *)jarg1;
8605   result = (float) ((arg1)->y);
8606   jresult = result;
8607   return jresult;
8608 }
8609
8610
8611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8613   float arg2 ;
8614
8615   arg1 = (Dali::Vector4 *)jarg1;
8616   arg2 = (float)jarg2;
8617   if (arg1) (arg1)->g = arg2;
8618 }
8619
8620
8621 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8622   float jresult ;
8623   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8624   float result;
8625
8626   arg1 = (Dali::Vector4 *)jarg1;
8627   result = (float) ((arg1)->g);
8628   jresult = result;
8629   return jresult;
8630 }
8631
8632
8633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8634   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8635   float arg2 ;
8636
8637   arg1 = (Dali::Vector4 *)jarg1;
8638   arg2 = (float)jarg2;
8639   if (arg1) (arg1)->t = arg2;
8640 }
8641
8642
8643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8644   float jresult ;
8645   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8646   float result;
8647
8648   arg1 = (Dali::Vector4 *)jarg1;
8649   result = (float) ((arg1)->t);
8650   jresult = result;
8651   return jresult;
8652 }
8653
8654
8655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8656   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8657   float arg2 ;
8658
8659   arg1 = (Dali::Vector4 *)jarg1;
8660   arg2 = (float)jarg2;
8661   if (arg1) (arg1)->z = arg2;
8662 }
8663
8664
8665 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8666   float jresult ;
8667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8668   float result;
8669
8670   arg1 = (Dali::Vector4 *)jarg1;
8671   result = (float) ((arg1)->z);
8672   jresult = result;
8673   return jresult;
8674 }
8675
8676
8677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8679   float arg2 ;
8680
8681   arg1 = (Dali::Vector4 *)jarg1;
8682   arg2 = (float)jarg2;
8683   if (arg1) (arg1)->b = arg2;
8684 }
8685
8686
8687 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8688   float jresult ;
8689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8690   float result;
8691
8692   arg1 = (Dali::Vector4 *)jarg1;
8693   result = (float) ((arg1)->b);
8694   jresult = result;
8695   return jresult;
8696 }
8697
8698
8699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8701   float arg2 ;
8702
8703   arg1 = (Dali::Vector4 *)jarg1;
8704   arg2 = (float)jarg2;
8705   if (arg1) (arg1)->p = arg2;
8706 }
8707
8708
8709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8710   float jresult ;
8711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8712   float result;
8713
8714   arg1 = (Dali::Vector4 *)jarg1;
8715   result = (float) ((arg1)->p);
8716   jresult = result;
8717   return jresult;
8718 }
8719
8720
8721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8723   float arg2 ;
8724
8725   arg1 = (Dali::Vector4 *)jarg1;
8726   arg2 = (float)jarg2;
8727   if (arg1) (arg1)->w = arg2;
8728 }
8729
8730
8731 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8732   float jresult ;
8733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8734   float result;
8735
8736   arg1 = (Dali::Vector4 *)jarg1;
8737   result = (float) ((arg1)->w);
8738   jresult = result;
8739   return jresult;
8740 }
8741
8742
8743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8745   float arg2 ;
8746
8747   arg1 = (Dali::Vector4 *)jarg1;
8748   arg2 = (float)jarg2;
8749   if (arg1) (arg1)->a = arg2;
8750 }
8751
8752
8753 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8754   float jresult ;
8755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8756   float result;
8757
8758   arg1 = (Dali::Vector4 *)jarg1;
8759   result = (float) ((arg1)->a);
8760   jresult = result;
8761   return jresult;
8762 }
8763
8764
8765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8767   float arg2 ;
8768
8769   arg1 = (Dali::Vector4 *)jarg1;
8770   arg2 = (float)jarg2;
8771   if (arg1) (arg1)->q = arg2;
8772 }
8773
8774
8775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8776   float jresult ;
8777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8778   float result;
8779
8780   arg1 = (Dali::Vector4 *)jarg1;
8781   result = (float) ((arg1)->q);
8782   jresult = result;
8783   return jresult;
8784 }
8785
8786
8787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8788   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8789
8790   arg1 = (Dali::Vector4 *)jarg1;
8791   {
8792     try {
8793       delete arg1;
8794     } catch (std::out_of_range& e) {
8795       {
8796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8797       };
8798     } catch (std::exception& e) {
8799       {
8800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8801       };
8802     } catch (Dali::DaliException e) {
8803       {
8804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8805       };
8806     } catch (...) {
8807       {
8808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8809       };
8810     }
8811   }
8812
8813 }
8814
8815
8816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8817   void * jresult ;
8818   Dali::Vector4 *arg1 = 0 ;
8819   Dali::Vector4 *arg2 = 0 ;
8820   Dali::Vector4 result;
8821
8822   arg1 = (Dali::Vector4 *)jarg1;
8823   if (!arg1) {
8824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8825     return 0;
8826   }
8827   arg2 = (Dali::Vector4 *)jarg2;
8828   if (!arg2) {
8829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8830     return 0;
8831   }
8832   {
8833     try {
8834       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8835     } catch (std::out_of_range& e) {
8836       {
8837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8838       };
8839     } catch (std::exception& e) {
8840       {
8841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8842       };
8843     } catch (Dali::DaliException e) {
8844       {
8845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8846       };
8847     } catch (...) {
8848       {
8849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8850       };
8851     }
8852   }
8853
8854   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8855   return jresult;
8856 }
8857
8858
8859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8860   void * jresult ;
8861   Dali::Vector4 *arg1 = 0 ;
8862   Dali::Vector4 *arg2 = 0 ;
8863   Dali::Vector4 result;
8864
8865   arg1 = (Dali::Vector4 *)jarg1;
8866   if (!arg1) {
8867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8868     return 0;
8869   }
8870   arg2 = (Dali::Vector4 *)jarg2;
8871   if (!arg2) {
8872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8873     return 0;
8874   }
8875   {
8876     try {
8877       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8878     } catch (std::out_of_range& e) {
8879       {
8880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8881       };
8882     } catch (std::exception& e) {
8883       {
8884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8885       };
8886     } catch (Dali::DaliException e) {
8887       {
8888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8889       };
8890     } catch (...) {
8891       {
8892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8893       };
8894     }
8895   }
8896
8897   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8898   return jresult;
8899 }
8900
8901
8902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8903   void * jresult ;
8904   Dali::Vector4 *arg1 = 0 ;
8905   float *arg2 = 0 ;
8906   float *arg3 = 0 ;
8907   float temp2 ;
8908   float temp3 ;
8909   Dali::Vector4 result;
8910
8911   arg1 = (Dali::Vector4 *)jarg1;
8912   if (!arg1) {
8913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8914     return 0;
8915   }
8916   temp2 = (float)jarg2;
8917   arg2 = &temp2;
8918   temp3 = (float)jarg3;
8919   arg3 = &temp3;
8920   {
8921     try {
8922       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8923     } catch (std::out_of_range& e) {
8924       {
8925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8926       };
8927     } catch (std::exception& e) {
8928       {
8929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8930       };
8931     } catch (Dali::DaliException e) {
8932       {
8933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8934       };
8935     } catch (...) {
8936       {
8937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8938       };
8939     }
8940   }
8941
8942   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8943   return jresult;
8944 }
8945
8946
8947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8948   void * jresult ;
8949   Dali::Uint16Pair *result = 0 ;
8950
8951   {
8952     try {
8953       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8954     } catch (std::out_of_range& e) {
8955       {
8956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8957       };
8958     } catch (std::exception& e) {
8959       {
8960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8961       };
8962     } catch (Dali::DaliException e) {
8963       {
8964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8965       };
8966     } catch (...) {
8967       {
8968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8969       };
8970     }
8971   }
8972
8973   jresult = (void *)result;
8974   return jresult;
8975 }
8976
8977
8978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8979   void * jresult ;
8980   uint32_t arg1 ;
8981   uint32_t arg2 ;
8982   Dali::Uint16Pair *result = 0 ;
8983
8984   arg1 = (uint32_t)jarg1;
8985   arg2 = (uint32_t)jarg2;
8986   {
8987     try {
8988       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8989     } catch (std::out_of_range& e) {
8990       {
8991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8992       };
8993     } catch (std::exception& e) {
8994       {
8995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8996       };
8997     } catch (Dali::DaliException e) {
8998       {
8999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9000       };
9001     } catch (...) {
9002       {
9003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9004       };
9005     }
9006   }
9007
9008   jresult = (void *)result;
9009   return jresult;
9010 }
9011
9012
9013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9014   void * jresult ;
9015   Dali::Uint16Pair *arg1 = 0 ;
9016   Dali::Uint16Pair *result = 0 ;
9017
9018   arg1 = (Dali::Uint16Pair *)jarg1;
9019   if (!arg1) {
9020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9021     return 0;
9022   }
9023   {
9024     try {
9025       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9026     } catch (std::out_of_range& e) {
9027       {
9028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9029       };
9030     } catch (std::exception& e) {
9031       {
9032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9033       };
9034     } catch (Dali::DaliException e) {
9035       {
9036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9037       };
9038     } catch (...) {
9039       {
9040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9041       };
9042     }
9043   }
9044
9045   jresult = (void *)result;
9046   return jresult;
9047 }
9048
9049
9050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9051   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9052   uint16_t arg2 ;
9053
9054   arg1 = (Dali::Uint16Pair *)jarg1;
9055   arg2 = (uint16_t)jarg2;
9056   {
9057     try {
9058       (arg1)->SetWidth(arg2);
9059     } catch (std::out_of_range& e) {
9060       {
9061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9062       };
9063     } catch (std::exception& e) {
9064       {
9065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9066       };
9067     } catch (Dali::DaliException e) {
9068       {
9069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9070       };
9071     } catch (...) {
9072       {
9073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9074       };
9075     }
9076   }
9077
9078 }
9079
9080
9081 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9082   unsigned short jresult ;
9083   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9084   uint16_t result;
9085
9086   arg1 = (Dali::Uint16Pair *)jarg1;
9087   {
9088     try {
9089       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9090     } catch (std::out_of_range& e) {
9091       {
9092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9093       };
9094     } catch (std::exception& e) {
9095       {
9096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9097       };
9098     } catch (Dali::DaliException e) {
9099       {
9100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9101       };
9102     } catch (...) {
9103       {
9104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9105       };
9106     }
9107   }
9108
9109   jresult = result;
9110   return jresult;
9111 }
9112
9113
9114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9115   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9116   uint16_t arg2 ;
9117
9118   arg1 = (Dali::Uint16Pair *)jarg1;
9119   arg2 = (uint16_t)jarg2;
9120   {
9121     try {
9122       (arg1)->SetHeight(arg2);
9123     } catch (std::out_of_range& e) {
9124       {
9125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9126       };
9127     } catch (std::exception& e) {
9128       {
9129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9130       };
9131     } catch (Dali::DaliException e) {
9132       {
9133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9134       };
9135     } catch (...) {
9136       {
9137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9138       };
9139     }
9140   }
9141
9142 }
9143
9144
9145 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9146   unsigned short jresult ;
9147   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9148   uint16_t result;
9149
9150   arg1 = (Dali::Uint16Pair *)jarg1;
9151   {
9152     try {
9153       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9154     } catch (std::out_of_range& e) {
9155       {
9156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9157       };
9158     } catch (std::exception& e) {
9159       {
9160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9161       };
9162     } catch (Dali::DaliException e) {
9163       {
9164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9165       };
9166     } catch (...) {
9167       {
9168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9169       };
9170     }
9171   }
9172
9173   jresult = result;
9174   return jresult;
9175 }
9176
9177
9178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9179   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9180   uint16_t arg2 ;
9181
9182   arg1 = (Dali::Uint16Pair *)jarg1;
9183   arg2 = (uint16_t)jarg2;
9184   {
9185     try {
9186       (arg1)->SetX(arg2);
9187     } catch (std::out_of_range& e) {
9188       {
9189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9190       };
9191     } catch (std::exception& e) {
9192       {
9193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9194       };
9195     } catch (Dali::DaliException e) {
9196       {
9197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9198       };
9199     } catch (...) {
9200       {
9201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9202       };
9203     }
9204   }
9205
9206 }
9207
9208
9209 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9210   unsigned short jresult ;
9211   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9212   uint16_t result;
9213
9214   arg1 = (Dali::Uint16Pair *)jarg1;
9215   {
9216     try {
9217       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9218     } catch (std::out_of_range& e) {
9219       {
9220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9221       };
9222     } catch (std::exception& e) {
9223       {
9224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9225       };
9226     } catch (Dali::DaliException e) {
9227       {
9228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9229       };
9230     } catch (...) {
9231       {
9232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9233       };
9234     }
9235   }
9236
9237   jresult = result;
9238   return jresult;
9239 }
9240
9241
9242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9243   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9244   uint16_t arg2 ;
9245
9246   arg1 = (Dali::Uint16Pair *)jarg1;
9247   arg2 = (uint16_t)jarg2;
9248   {
9249     try {
9250       (arg1)->SetY(arg2);
9251     } catch (std::out_of_range& e) {
9252       {
9253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9254       };
9255     } catch (std::exception& e) {
9256       {
9257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9258       };
9259     } catch (Dali::DaliException e) {
9260       {
9261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9262       };
9263     } catch (...) {
9264       {
9265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9266       };
9267     }
9268   }
9269
9270 }
9271
9272
9273 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9274   unsigned short jresult ;
9275   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9276   uint16_t result;
9277
9278   arg1 = (Dali::Uint16Pair *)jarg1;
9279   {
9280     try {
9281       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9282     } catch (std::out_of_range& e) {
9283       {
9284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9285       };
9286     } catch (std::exception& e) {
9287       {
9288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9289       };
9290     } catch (Dali::DaliException e) {
9291       {
9292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9293       };
9294     } catch (...) {
9295       {
9296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9297       };
9298     }
9299   }
9300
9301   jresult = result;
9302   return jresult;
9303 }
9304
9305
9306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9307   void * jresult ;
9308   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9309   Dali::Uint16Pair *arg2 = 0 ;
9310   Dali::Uint16Pair *result = 0 ;
9311
9312   arg1 = (Dali::Uint16Pair *)jarg1;
9313   arg2 = (Dali::Uint16Pair *)jarg2;
9314   if (!arg2) {
9315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9316     return 0;
9317   }
9318   {
9319     try {
9320       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9321     } catch (std::out_of_range& e) {
9322       {
9323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9324       };
9325     } catch (std::exception& e) {
9326       {
9327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9328       };
9329     } catch (Dali::DaliException e) {
9330       {
9331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9332       };
9333     } catch (...) {
9334       {
9335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9336       };
9337     }
9338   }
9339
9340   jresult = (void *)result;
9341   return jresult;
9342 }
9343
9344
9345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9346   unsigned int jresult ;
9347   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9348   Dali::Uint16Pair *arg2 = 0 ;
9349   bool result;
9350
9351   arg1 = (Dali::Uint16Pair *)jarg1;
9352   arg2 = (Dali::Uint16Pair *)jarg2;
9353   if (!arg2) {
9354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9355     return 0;
9356   }
9357   {
9358     try {
9359       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9360     } catch (std::out_of_range& e) {
9361       {
9362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9363       };
9364     } catch (std::exception& e) {
9365       {
9366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9367       };
9368     } catch (Dali::DaliException e) {
9369       {
9370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9371       };
9372     } catch (...) {
9373       {
9374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9375       };
9376     }
9377   }
9378
9379   jresult = result;
9380   return jresult;
9381 }
9382
9383
9384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9385   unsigned int jresult ;
9386   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9387   Dali::Uint16Pair *arg2 = 0 ;
9388   bool result;
9389
9390   arg1 = (Dali::Uint16Pair *)jarg1;
9391   arg2 = (Dali::Uint16Pair *)jarg2;
9392   if (!arg2) {
9393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9394     return 0;
9395   }
9396   {
9397     try {
9398       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9399     } catch (std::out_of_range& e) {
9400       {
9401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9402       };
9403     } catch (std::exception& e) {
9404       {
9405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9406       };
9407     } catch (Dali::DaliException e) {
9408       {
9409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9410       };
9411     } catch (...) {
9412       {
9413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9414       };
9415     }
9416   }
9417
9418   jresult = result;
9419   return jresult;
9420 }
9421
9422
9423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9424   unsigned int jresult ;
9425   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9426   Dali::Uint16Pair *arg2 = 0 ;
9427   bool result;
9428
9429   arg1 = (Dali::Uint16Pair *)jarg1;
9430   arg2 = (Dali::Uint16Pair *)jarg2;
9431   if (!arg2) {
9432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9433     return 0;
9434   }
9435   {
9436     try {
9437       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9438     } catch (std::out_of_range& e) {
9439       {
9440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9441       };
9442     } catch (std::exception& e) {
9443       {
9444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9445       };
9446     } catch (Dali::DaliException e) {
9447       {
9448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9449       };
9450     } catch (...) {
9451       {
9452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9453       };
9454     }
9455   }
9456
9457   jresult = result;
9458   return jresult;
9459 }
9460
9461
9462 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9463   unsigned int jresult ;
9464   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9465   Dali::Uint16Pair *arg2 = 0 ;
9466   bool result;
9467
9468   arg1 = (Dali::Uint16Pair *)jarg1;
9469   arg2 = (Dali::Uint16Pair *)jarg2;
9470   if (!arg2) {
9471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9472     return 0;
9473   }
9474   {
9475     try {
9476       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9477     } catch (std::out_of_range& e) {
9478       {
9479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9480       };
9481     } catch (std::exception& e) {
9482       {
9483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9484       };
9485     } catch (Dali::DaliException e) {
9486       {
9487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9488       };
9489     } catch (...) {
9490       {
9491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9492       };
9493     }
9494   }
9495
9496   jresult = result;
9497   return jresult;
9498 }
9499
9500
9501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9502   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9503
9504   arg1 = (Dali::Uint16Pair *)jarg1;
9505   {
9506     try {
9507       delete arg1;
9508     } catch (std::out_of_range& e) {
9509       {
9510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9511       };
9512     } catch (std::exception& e) {
9513       {
9514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9515       };
9516     } catch (Dali::DaliException e) {
9517       {
9518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9519       };
9520     } catch (...) {
9521       {
9522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9523       };
9524     }
9525   }
9526
9527 }
9528
9529
9530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9531   void * jresult ;
9532   Dali::Degree *result = 0 ;
9533
9534   {
9535     try {
9536       result = (Dali::Degree *)new Dali::Degree();
9537     } catch (std::out_of_range& e) {
9538       {
9539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9540       };
9541     } catch (std::exception& e) {
9542       {
9543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9544       };
9545     } catch (Dali::DaliException e) {
9546       {
9547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9548       };
9549     } catch (...) {
9550       {
9551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9552       };
9553     }
9554   }
9555
9556   jresult = (void *)result;
9557   return jresult;
9558 }
9559
9560
9561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9562   void * jresult ;
9563   float arg1 ;
9564   Dali::Degree *result = 0 ;
9565
9566   arg1 = (float)jarg1;
9567   {
9568     try {
9569       result = (Dali::Degree *)new Dali::Degree(arg1);
9570     } catch (std::out_of_range& e) {
9571       {
9572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9573       };
9574     } catch (std::exception& e) {
9575       {
9576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9577       };
9578     } catch (Dali::DaliException e) {
9579       {
9580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9581       };
9582     } catch (...) {
9583       {
9584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9585       };
9586     }
9587   }
9588
9589   jresult = (void *)result;
9590   return jresult;
9591 }
9592
9593
9594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9595   void * jresult ;
9596   Dali::Radian arg1 ;
9597   Dali::Radian *argp1 ;
9598   Dali::Degree *result = 0 ;
9599
9600   argp1 = (Dali::Radian *)jarg1;
9601   if (!argp1) {
9602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9603     return 0;
9604   }
9605   arg1 = *argp1;
9606   {
9607     try {
9608       result = (Dali::Degree *)new Dali::Degree(arg1);
9609     } catch (std::out_of_range& e) {
9610       {
9611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9612       };
9613     } catch (std::exception& e) {
9614       {
9615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9616       };
9617     } catch (Dali::DaliException e) {
9618       {
9619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9620       };
9621     } catch (...) {
9622       {
9623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9624       };
9625     }
9626   }
9627
9628   jresult = (void *)result;
9629   return jresult;
9630 }
9631
9632
9633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9634   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9635   float arg2 ;
9636
9637   arg1 = (Dali::Degree *)jarg1;
9638   arg2 = (float)jarg2;
9639   if (arg1) (arg1)->degree = arg2;
9640 }
9641
9642
9643 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9644   float jresult ;
9645   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9646   float result;
9647
9648   arg1 = (Dali::Degree *)jarg1;
9649   result = (float) ((arg1)->degree);
9650   jresult = result;
9651   return jresult;
9652 }
9653
9654
9655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9656   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9657
9658   arg1 = (Dali::Degree *)jarg1;
9659   {
9660     try {
9661       delete arg1;
9662     } catch (std::out_of_range& e) {
9663       {
9664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9665       };
9666     } catch (std::exception& e) {
9667       {
9668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9669       };
9670     } catch (Dali::DaliException e) {
9671       {
9672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9673       };
9674     } catch (...) {
9675       {
9676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9677       };
9678     }
9679   }
9680
9681 }
9682
9683
9684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9685   void * jresult ;
9686   Dali::Radian *result = 0 ;
9687
9688   result = (Dali::Radian *)&Dali::ANGLE_360;
9689   jresult = (void *)result;
9690   return jresult;
9691 }
9692
9693
9694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9695   void * jresult ;
9696   Dali::Radian *result = 0 ;
9697
9698   result = (Dali::Radian *)&Dali::ANGLE_315;
9699   jresult = (void *)result;
9700   return jresult;
9701 }
9702
9703
9704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9705   void * jresult ;
9706   Dali::Radian *result = 0 ;
9707
9708   result = (Dali::Radian *)&Dali::ANGLE_270;
9709   jresult = (void *)result;
9710   return jresult;
9711 }
9712
9713
9714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9715   void * jresult ;
9716   Dali::Radian *result = 0 ;
9717
9718   result = (Dali::Radian *)&Dali::ANGLE_225;
9719   jresult = (void *)result;
9720   return jresult;
9721 }
9722
9723
9724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9725   void * jresult ;
9726   Dali::Radian *result = 0 ;
9727
9728   result = (Dali::Radian *)&Dali::ANGLE_180;
9729   jresult = (void *)result;
9730   return jresult;
9731 }
9732
9733
9734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9735   void * jresult ;
9736   Dali::Radian *result = 0 ;
9737
9738   result = (Dali::Radian *)&Dali::ANGLE_135;
9739   jresult = (void *)result;
9740   return jresult;
9741 }
9742
9743
9744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9745   void * jresult ;
9746   Dali::Radian *result = 0 ;
9747
9748   result = (Dali::Radian *)&Dali::ANGLE_120;
9749   jresult = (void *)result;
9750   return jresult;
9751 }
9752
9753
9754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9755   void * jresult ;
9756   Dali::Radian *result = 0 ;
9757
9758   result = (Dali::Radian *)&Dali::ANGLE_90;
9759   jresult = (void *)result;
9760   return jresult;
9761 }
9762
9763
9764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9765   void * jresult ;
9766   Dali::Radian *result = 0 ;
9767
9768   result = (Dali::Radian *)&Dali::ANGLE_60;
9769   jresult = (void *)result;
9770   return jresult;
9771 }
9772
9773
9774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9775   void * jresult ;
9776   Dali::Radian *result = 0 ;
9777
9778   result = (Dali::Radian *)&Dali::ANGLE_45;
9779   jresult = (void *)result;
9780   return jresult;
9781 }
9782
9783
9784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9785   void * jresult ;
9786   Dali::Radian *result = 0 ;
9787
9788   result = (Dali::Radian *)&Dali::ANGLE_30;
9789   jresult = (void *)result;
9790   return jresult;
9791 }
9792
9793
9794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9795   void * jresult ;
9796   Dali::Radian *result = 0 ;
9797
9798   result = (Dali::Radian *)&Dali::ANGLE_0;
9799   jresult = (void *)result;
9800   return jresult;
9801 }
9802
9803
9804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9805   unsigned int jresult ;
9806   Dali::Degree *arg1 = 0 ;
9807   Dali::Degree *arg2 = 0 ;
9808   bool result;
9809
9810   arg1 = (Dali::Degree *)jarg1;
9811   if (!arg1) {
9812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9813     return 0;
9814   }
9815   arg2 = (Dali::Degree *)jarg2;
9816   if (!arg2) {
9817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9818     return 0;
9819   }
9820   {
9821     try {
9822       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9823     } catch (std::out_of_range& e) {
9824       {
9825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9826       };
9827     } catch (std::exception& e) {
9828       {
9829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9830       };
9831     } catch (Dali::DaliException e) {
9832       {
9833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9834       };
9835     } catch (...) {
9836       {
9837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9838       };
9839     }
9840   }
9841
9842   jresult = result;
9843   return jresult;
9844 }
9845
9846
9847 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9848   unsigned int jresult ;
9849   Dali::Degree *arg1 = 0 ;
9850   Dali::Degree *arg2 = 0 ;
9851   bool result;
9852
9853   arg1 = (Dali::Degree *)jarg1;
9854   if (!arg1) {
9855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9856     return 0;
9857   }
9858   arg2 = (Dali::Degree *)jarg2;
9859   if (!arg2) {
9860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9861     return 0;
9862   }
9863   {
9864     try {
9865       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9866     } catch (std::out_of_range& e) {
9867       {
9868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9869       };
9870     } catch (std::exception& e) {
9871       {
9872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9873       };
9874     } catch (Dali::DaliException e) {
9875       {
9876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9877       };
9878     } catch (...) {
9879       {
9880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9881       };
9882     }
9883   }
9884
9885   jresult = result;
9886   return jresult;
9887 }
9888
9889
9890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9891   void * jresult ;
9892   Dali::Degree arg1 ;
9893   float arg2 ;
9894   float arg3 ;
9895   Dali::Degree *argp1 ;
9896   Dali::Degree result;
9897
9898   argp1 = (Dali::Degree *)jarg1;
9899   if (!argp1) {
9900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9901     return 0;
9902   }
9903   arg1 = *argp1;
9904   arg2 = (float)jarg2;
9905   arg3 = (float)jarg3;
9906   {
9907     try {
9908       result = Dali::Clamp(arg1,arg2,arg3);
9909     } catch (std::out_of_range& e) {
9910       {
9911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9912       };
9913     } catch (std::exception& e) {
9914       {
9915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9916       };
9917     } catch (Dali::DaliException e) {
9918       {
9919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9920       };
9921     } catch (...) {
9922       {
9923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9924       };
9925     }
9926   }
9927
9928   jresult = new Dali::Degree((const Dali::Degree &)result);
9929   return jresult;
9930 }
9931
9932
9933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9934   void * jresult ;
9935   Dali::Radian *result = 0 ;
9936
9937   {
9938     try {
9939       result = (Dali::Radian *)new Dali::Radian();
9940     } catch (std::out_of_range& e) {
9941       {
9942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9943       };
9944     } catch (std::exception& e) {
9945       {
9946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9947       };
9948     } catch (Dali::DaliException e) {
9949       {
9950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9951       };
9952     } catch (...) {
9953       {
9954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9955       };
9956     }
9957   }
9958
9959   jresult = (void *)result;
9960   return jresult;
9961 }
9962
9963
9964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9965   void * jresult ;
9966   float arg1 ;
9967   Dali::Radian *result = 0 ;
9968
9969   arg1 = (float)jarg1;
9970   {
9971     try {
9972       result = (Dali::Radian *)new Dali::Radian(arg1);
9973     } catch (std::out_of_range& e) {
9974       {
9975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9976       };
9977     } catch (std::exception& e) {
9978       {
9979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9980       };
9981     } catch (Dali::DaliException e) {
9982       {
9983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9984       };
9985     } catch (...) {
9986       {
9987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9988       };
9989     }
9990   }
9991
9992   jresult = (void *)result;
9993   return jresult;
9994 }
9995
9996
9997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9998   void * jresult ;
9999   Dali::Degree arg1 ;
10000   Dali::Degree *argp1 ;
10001   Dali::Radian *result = 0 ;
10002
10003   argp1 = (Dali::Degree *)jarg1;
10004   if (!argp1) {
10005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10006     return 0;
10007   }
10008   arg1 = *argp1;
10009   {
10010     try {
10011       result = (Dali::Radian *)new Dali::Radian(arg1);
10012     } catch (std::out_of_range& e) {
10013       {
10014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10015       };
10016     } catch (std::exception& e) {
10017       {
10018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10019       };
10020     } catch (Dali::DaliException e) {
10021       {
10022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10023       };
10024     } catch (...) {
10025       {
10026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10027       };
10028     }
10029   }
10030
10031   jresult = (void *)result;
10032   return jresult;
10033 }
10034
10035
10036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10037   void * jresult ;
10038   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10039   float arg2 ;
10040   Dali::Radian *result = 0 ;
10041
10042   arg1 = (Dali::Radian *)jarg1;
10043   arg2 = (float)jarg2;
10044   {
10045     try {
10046       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10047     } catch (std::out_of_range& e) {
10048       {
10049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10050       };
10051     } catch (std::exception& e) {
10052       {
10053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10054       };
10055     } catch (Dali::DaliException e) {
10056       {
10057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10058       };
10059     } catch (...) {
10060       {
10061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10062       };
10063     }
10064   }
10065
10066   jresult = (void *)result;
10067   return jresult;
10068 }
10069
10070
10071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10072   void * jresult ;
10073   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10074   Dali::Degree arg2 ;
10075   Dali::Degree *argp2 ;
10076   Dali::Radian *result = 0 ;
10077
10078   arg1 = (Dali::Radian *)jarg1;
10079   argp2 = (Dali::Degree *)jarg2;
10080   if (!argp2) {
10081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10082     return 0;
10083   }
10084   arg2 = *argp2;
10085   {
10086     try {
10087       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10088     } catch (std::out_of_range& e) {
10089       {
10090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10091       };
10092     } catch (std::exception& e) {
10093       {
10094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10095       };
10096     } catch (Dali::DaliException e) {
10097       {
10098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10099       };
10100     } catch (...) {
10101       {
10102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10103       };
10104     }
10105   }
10106
10107   jresult = (void *)result;
10108   return jresult;
10109 }
10110
10111
10112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10113   float jresult ;
10114   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10115   float result;
10116
10117   arg1 = (Dali::Radian *)jarg1;
10118   {
10119     try {
10120       result = (float)((Dali::Radian const *)arg1)->operator float();
10121     } catch (std::out_of_range& e) {
10122       {
10123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10124       };
10125     } catch (std::exception& e) {
10126       {
10127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10128       };
10129     } catch (Dali::DaliException e) {
10130       {
10131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10132       };
10133     } catch (...) {
10134       {
10135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10136       };
10137     }
10138   }
10139
10140   jresult = result;
10141   return jresult;
10142 }
10143
10144
10145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10146   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10147   float arg2 ;
10148
10149   arg1 = (Dali::Radian *)jarg1;
10150   arg2 = (float)jarg2;
10151   if (arg1) (arg1)->radian = arg2;
10152 }
10153
10154
10155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10156   float jresult ;
10157   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10158   float result;
10159
10160   arg1 = (Dali::Radian *)jarg1;
10161   result = (float) ((arg1)->radian);
10162   jresult = result;
10163   return jresult;
10164 }
10165
10166
10167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10168   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10169
10170   arg1 = (Dali::Radian *)jarg1;
10171   {
10172     try {
10173       delete arg1;
10174     } catch (std::out_of_range& e) {
10175       {
10176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10177       };
10178     } catch (std::exception& e) {
10179       {
10180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10181       };
10182     } catch (Dali::DaliException e) {
10183       {
10184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10185       };
10186     } catch (...) {
10187       {
10188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10189       };
10190     }
10191   }
10192
10193 }
10194
10195
10196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10197   unsigned int jresult ;
10198   Dali::Radian arg1 ;
10199   Dali::Radian arg2 ;
10200   Dali::Radian *argp1 ;
10201   Dali::Radian *argp2 ;
10202   bool result;
10203
10204   argp1 = (Dali::Radian *)jarg1;
10205   if (!argp1) {
10206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10207     return 0;
10208   }
10209   arg1 = *argp1;
10210   argp2 = (Dali::Radian *)jarg2;
10211   if (!argp2) {
10212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10213     return 0;
10214   }
10215   arg2 = *argp2;
10216   {
10217     try {
10218       result = (bool)Dali::operator ==(arg1,arg2);
10219     } catch (std::out_of_range& e) {
10220       {
10221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10222       };
10223     } catch (std::exception& e) {
10224       {
10225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10226       };
10227     } catch (Dali::DaliException e) {
10228       {
10229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10230       };
10231     } catch (...) {
10232       {
10233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10234       };
10235     }
10236   }
10237
10238   jresult = result;
10239   return jresult;
10240 }
10241
10242
10243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10244   unsigned int jresult ;
10245   Dali::Radian arg1 ;
10246   Dali::Radian arg2 ;
10247   Dali::Radian *argp1 ;
10248   Dali::Radian *argp2 ;
10249   bool result;
10250
10251   argp1 = (Dali::Radian *)jarg1;
10252   if (!argp1) {
10253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10254     return 0;
10255   }
10256   arg1 = *argp1;
10257   argp2 = (Dali::Radian *)jarg2;
10258   if (!argp2) {
10259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10260     return 0;
10261   }
10262   arg2 = *argp2;
10263   {
10264     try {
10265       result = (bool)Dali::operator !=(arg1,arg2);
10266     } catch (std::out_of_range& e) {
10267       {
10268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10269       };
10270     } catch (std::exception& e) {
10271       {
10272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10273       };
10274     } catch (Dali::DaliException e) {
10275       {
10276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10277       };
10278     } catch (...) {
10279       {
10280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10281       };
10282     }
10283   }
10284
10285   jresult = result;
10286   return jresult;
10287 }
10288
10289
10290 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10291   unsigned int jresult ;
10292   Dali::Radian arg1 ;
10293   Dali::Degree arg2 ;
10294   Dali::Radian *argp1 ;
10295   Dali::Degree *argp2 ;
10296   bool result;
10297
10298   argp1 = (Dali::Radian *)jarg1;
10299   if (!argp1) {
10300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10301     return 0;
10302   }
10303   arg1 = *argp1;
10304   argp2 = (Dali::Degree *)jarg2;
10305   if (!argp2) {
10306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10307     return 0;
10308   }
10309   arg2 = *argp2;
10310   {
10311     try {
10312       result = (bool)Dali::operator ==(arg1,arg2);
10313     } catch (std::out_of_range& e) {
10314       {
10315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10316       };
10317     } catch (std::exception& e) {
10318       {
10319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10320       };
10321     } catch (Dali::DaliException e) {
10322       {
10323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10324       };
10325     } catch (...) {
10326       {
10327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10328       };
10329     }
10330   }
10331
10332   jresult = result;
10333   return jresult;
10334 }
10335
10336
10337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10338   unsigned int jresult ;
10339   Dali::Radian arg1 ;
10340   Dali::Degree arg2 ;
10341   Dali::Radian *argp1 ;
10342   Dali::Degree *argp2 ;
10343   bool result;
10344
10345   argp1 = (Dali::Radian *)jarg1;
10346   if (!argp1) {
10347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10348     return 0;
10349   }
10350   arg1 = *argp1;
10351   argp2 = (Dali::Degree *)jarg2;
10352   if (!argp2) {
10353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10354     return 0;
10355   }
10356   arg2 = *argp2;
10357   {
10358     try {
10359       result = (bool)Dali::operator !=(arg1,arg2);
10360     } catch (std::out_of_range& e) {
10361       {
10362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10363       };
10364     } catch (std::exception& e) {
10365       {
10366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10367       };
10368     } catch (Dali::DaliException e) {
10369       {
10370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10371       };
10372     } catch (...) {
10373       {
10374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10375       };
10376     }
10377   }
10378
10379   jresult = result;
10380   return jresult;
10381 }
10382
10383
10384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10385   unsigned int jresult ;
10386   Dali::Degree arg1 ;
10387   Dali::Radian arg2 ;
10388   Dali::Degree *argp1 ;
10389   Dali::Radian *argp2 ;
10390   bool result;
10391
10392   argp1 = (Dali::Degree *)jarg1;
10393   if (!argp1) {
10394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10395     return 0;
10396   }
10397   arg1 = *argp1;
10398   argp2 = (Dali::Radian *)jarg2;
10399   if (!argp2) {
10400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10401     return 0;
10402   }
10403   arg2 = *argp2;
10404   {
10405     try {
10406       result = (bool)Dali::operator ==(arg1,arg2);
10407     } catch (std::out_of_range& e) {
10408       {
10409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10410       };
10411     } catch (std::exception& e) {
10412       {
10413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10414       };
10415     } catch (Dali::DaliException e) {
10416       {
10417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10418       };
10419     } catch (...) {
10420       {
10421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10422       };
10423     }
10424   }
10425
10426   jresult = result;
10427   return jresult;
10428 }
10429
10430
10431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10432   unsigned int jresult ;
10433   Dali::Degree arg1 ;
10434   Dali::Radian arg2 ;
10435   Dali::Degree *argp1 ;
10436   Dali::Radian *argp2 ;
10437   bool result;
10438
10439   argp1 = (Dali::Degree *)jarg1;
10440   if (!argp1) {
10441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10442     return 0;
10443   }
10444   arg1 = *argp1;
10445   argp2 = (Dali::Radian *)jarg2;
10446   if (!argp2) {
10447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10448     return 0;
10449   }
10450   arg2 = *argp2;
10451   {
10452     try {
10453       result = (bool)Dali::operator !=(arg1,arg2);
10454     } catch (std::out_of_range& e) {
10455       {
10456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10457       };
10458     } catch (std::exception& e) {
10459       {
10460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10461       };
10462     } catch (Dali::DaliException e) {
10463       {
10464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10465       };
10466     } catch (...) {
10467       {
10468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10469       };
10470     }
10471   }
10472
10473   jresult = result;
10474   return jresult;
10475 }
10476
10477
10478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10479   unsigned int jresult ;
10480   Dali::Radian arg1 ;
10481   Dali::Radian arg2 ;
10482   Dali::Radian *argp1 ;
10483   Dali::Radian *argp2 ;
10484   bool result;
10485
10486   argp1 = (Dali::Radian *)jarg1;
10487   if (!argp1) {
10488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10489     return 0;
10490   }
10491   arg1 = *argp1;
10492   argp2 = (Dali::Radian *)jarg2;
10493   if (!argp2) {
10494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10495     return 0;
10496   }
10497   arg2 = *argp2;
10498   {
10499     try {
10500       result = (bool)Dali::operator >(arg1,arg2);
10501     } catch (std::out_of_range& e) {
10502       {
10503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10504       };
10505     } catch (std::exception& e) {
10506       {
10507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10508       };
10509     } catch (Dali::DaliException e) {
10510       {
10511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10512       };
10513     } catch (...) {
10514       {
10515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10516       };
10517     }
10518   }
10519
10520   jresult = result;
10521   return jresult;
10522 }
10523
10524
10525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10526   unsigned int jresult ;
10527   Dali::Radian arg1 ;
10528   Dali::Degree arg2 ;
10529   Dali::Radian *argp1 ;
10530   Dali::Degree *argp2 ;
10531   bool result;
10532
10533   argp1 = (Dali::Radian *)jarg1;
10534   if (!argp1) {
10535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10536     return 0;
10537   }
10538   arg1 = *argp1;
10539   argp2 = (Dali::Degree *)jarg2;
10540   if (!argp2) {
10541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10542     return 0;
10543   }
10544   arg2 = *argp2;
10545   {
10546     try {
10547       result = (bool)Dali::operator >(arg1,arg2);
10548     } catch (std::out_of_range& e) {
10549       {
10550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10551       };
10552     } catch (std::exception& e) {
10553       {
10554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10555       };
10556     } catch (Dali::DaliException e) {
10557       {
10558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10559       };
10560     } catch (...) {
10561       {
10562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10563       };
10564     }
10565   }
10566
10567   jresult = result;
10568   return jresult;
10569 }
10570
10571
10572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10573   unsigned int jresult ;
10574   Dali::Degree arg1 ;
10575   Dali::Radian arg2 ;
10576   Dali::Degree *argp1 ;
10577   Dali::Radian *argp2 ;
10578   bool result;
10579
10580   argp1 = (Dali::Degree *)jarg1;
10581   if (!argp1) {
10582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10583     return 0;
10584   }
10585   arg1 = *argp1;
10586   argp2 = (Dali::Radian *)jarg2;
10587   if (!argp2) {
10588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10589     return 0;
10590   }
10591   arg2 = *argp2;
10592   {
10593     try {
10594       result = (bool)Dali::operator >(arg1,arg2);
10595     } catch (std::out_of_range& e) {
10596       {
10597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10598       };
10599     } catch (std::exception& e) {
10600       {
10601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10602       };
10603     } catch (Dali::DaliException e) {
10604       {
10605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10606       };
10607     } catch (...) {
10608       {
10609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10610       };
10611     }
10612   }
10613
10614   jresult = result;
10615   return jresult;
10616 }
10617
10618
10619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10620   unsigned int jresult ;
10621   Dali::Radian arg1 ;
10622   Dali::Radian arg2 ;
10623   Dali::Radian *argp1 ;
10624   Dali::Radian *argp2 ;
10625   bool result;
10626
10627   argp1 = (Dali::Radian *)jarg1;
10628   if (!argp1) {
10629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10630     return 0;
10631   }
10632   arg1 = *argp1;
10633   argp2 = (Dali::Radian *)jarg2;
10634   if (!argp2) {
10635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10636     return 0;
10637   }
10638   arg2 = *argp2;
10639   {
10640     try {
10641       result = (bool)Dali::operator <(arg1,arg2);
10642     } catch (std::out_of_range& e) {
10643       {
10644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10645       };
10646     } catch (std::exception& e) {
10647       {
10648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10649       };
10650     } catch (Dali::DaliException e) {
10651       {
10652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10653       };
10654     } catch (...) {
10655       {
10656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10657       };
10658     }
10659   }
10660
10661   jresult = result;
10662   return jresult;
10663 }
10664
10665
10666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10667   unsigned int jresult ;
10668   Dali::Radian arg1 ;
10669   Dali::Degree arg2 ;
10670   Dali::Radian *argp1 ;
10671   Dali::Degree *argp2 ;
10672   bool result;
10673
10674   argp1 = (Dali::Radian *)jarg1;
10675   if (!argp1) {
10676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10677     return 0;
10678   }
10679   arg1 = *argp1;
10680   argp2 = (Dali::Degree *)jarg2;
10681   if (!argp2) {
10682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10683     return 0;
10684   }
10685   arg2 = *argp2;
10686   {
10687     try {
10688       result = (bool)Dali::operator <(arg1,arg2);
10689     } catch (std::out_of_range& e) {
10690       {
10691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10692       };
10693     } catch (std::exception& e) {
10694       {
10695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10696       };
10697     } catch (Dali::DaliException e) {
10698       {
10699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10700       };
10701     } catch (...) {
10702       {
10703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10704       };
10705     }
10706   }
10707
10708   jresult = result;
10709   return jresult;
10710 }
10711
10712
10713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10714   unsigned int jresult ;
10715   Dali::Degree arg1 ;
10716   Dali::Radian arg2 ;
10717   Dali::Degree *argp1 ;
10718   Dali::Radian *argp2 ;
10719   bool result;
10720
10721   argp1 = (Dali::Degree *)jarg1;
10722   if (!argp1) {
10723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10724     return 0;
10725   }
10726   arg1 = *argp1;
10727   argp2 = (Dali::Radian *)jarg2;
10728   if (!argp2) {
10729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10730     return 0;
10731   }
10732   arg2 = *argp2;
10733   {
10734     try {
10735       result = (bool)Dali::operator <(arg1,arg2);
10736     } catch (std::out_of_range& e) {
10737       {
10738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10739       };
10740     } catch (std::exception& e) {
10741       {
10742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10743       };
10744     } catch (Dali::DaliException e) {
10745       {
10746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10747       };
10748     } catch (...) {
10749       {
10750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10751       };
10752     }
10753   }
10754
10755   jresult = result;
10756   return jresult;
10757 }
10758
10759
10760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10761   void * jresult ;
10762   Dali::Radian arg1 ;
10763   float arg2 ;
10764   Dali::Radian *argp1 ;
10765   Dali::Radian result;
10766
10767   argp1 = (Dali::Radian *)jarg1;
10768   if (!argp1) {
10769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10770     return 0;
10771   }
10772   arg1 = *argp1;
10773   arg2 = (float)jarg2;
10774   {
10775     try {
10776       result = Dali::operator *(arg1,arg2);
10777     } catch (std::out_of_range& e) {
10778       {
10779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10780       };
10781     } catch (std::exception& e) {
10782       {
10783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10784       };
10785     } catch (Dali::DaliException e) {
10786       {
10787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10788       };
10789     } catch (...) {
10790       {
10791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10792       };
10793     }
10794   }
10795
10796   jresult = new Dali::Radian((const Dali::Radian &)result);
10797   return jresult;
10798 }
10799
10800
10801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10802   void * jresult ;
10803   Dali::Radian arg1 ;
10804   Dali::Radian *argp1 ;
10805   Dali::Radian result;
10806
10807   argp1 = (Dali::Radian *)jarg1;
10808   if (!argp1) {
10809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10810     return 0;
10811   }
10812   arg1 = *argp1;
10813   {
10814     try {
10815       result = Dali::operator -(arg1);
10816     } catch (std::out_of_range& e) {
10817       {
10818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10819       };
10820     } catch (std::exception& e) {
10821       {
10822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10823       };
10824     } catch (Dali::DaliException e) {
10825       {
10826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10827       };
10828     } catch (...) {
10829       {
10830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10831       };
10832     }
10833   }
10834
10835   jresult = new Dali::Radian((const Dali::Radian &)result);
10836   return jresult;
10837 }
10838
10839
10840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10841   void * jresult ;
10842   Dali::Radian arg1 ;
10843   float arg2 ;
10844   float arg3 ;
10845   Dali::Radian *argp1 ;
10846   Dali::Radian result;
10847
10848   argp1 = (Dali::Radian *)jarg1;
10849   if (!argp1) {
10850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10851     return 0;
10852   }
10853   arg1 = *argp1;
10854   arg2 = (float)jarg2;
10855   arg3 = (float)jarg3;
10856   {
10857     try {
10858       result = Dali::Clamp(arg1,arg2,arg3);
10859     } catch (std::out_of_range& e) {
10860       {
10861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10862       };
10863     } catch (std::exception& e) {
10864       {
10865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10866       };
10867     } catch (Dali::DaliException e) {
10868       {
10869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10870       };
10871     } catch (...) {
10872       {
10873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10874       };
10875     }
10876   }
10877
10878   jresult = new Dali::Radian((const Dali::Radian &)result);
10879   return jresult;
10880 }
10881
10882
10883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10884   void * jresult ;
10885   Dali::Quaternion *result = 0 ;
10886
10887   {
10888     try {
10889       result = (Dali::Quaternion *)new Dali::Quaternion();
10890     } catch (std::out_of_range& e) {
10891       {
10892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10893       };
10894     } catch (std::exception& e) {
10895       {
10896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10897       };
10898     } catch (Dali::DaliException e) {
10899       {
10900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10901       };
10902     } catch (...) {
10903       {
10904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10905       };
10906     }
10907   }
10908
10909   jresult = (void *)result;
10910   return jresult;
10911 }
10912
10913
10914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10915   void * jresult ;
10916   Dali::Radian arg1 ;
10917   Dali::Vector3 *arg2 = 0 ;
10918   Dali::Radian *argp1 ;
10919   Dali::Quaternion *result = 0 ;
10920
10921   argp1 = (Dali::Radian *)jarg1;
10922   if (!argp1) {
10923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10924     return 0;
10925   }
10926   arg1 = *argp1;
10927   arg2 = (Dali::Vector3 *)jarg2;
10928   if (!arg2) {
10929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10930     return 0;
10931   }
10932   {
10933     try {
10934       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10935     } catch (std::out_of_range& e) {
10936       {
10937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10938       };
10939     } catch (std::exception& e) {
10940       {
10941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10942       };
10943     } catch (Dali::DaliException e) {
10944       {
10945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10946       };
10947     } catch (...) {
10948       {
10949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10950       };
10951     }
10952   }
10953
10954   jresult = (void *)result;
10955   return jresult;
10956 }
10957
10958
10959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10960   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10961
10962   arg1 = (Dali::Quaternion *)jarg1;
10963   {
10964     try {
10965       delete arg1;
10966     } catch (std::out_of_range& e) {
10967       {
10968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10969       };
10970     } catch (std::exception& e) {
10971       {
10972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10973       };
10974     } catch (Dali::DaliException e) {
10975       {
10976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10977       };
10978     } catch (...) {
10979       {
10980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10981       };
10982     }
10983   }
10984
10985 }
10986
10987
10988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10989   void * jresult ;
10990   Dali::Quaternion *result = 0 ;
10991
10992   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10993   jresult = (void *)result;
10994   return jresult;
10995 }
10996
10997
10998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10999   unsigned int jresult ;
11000   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11001   bool result;
11002
11003   arg1 = (Dali::Quaternion *)jarg1;
11004   {
11005     try {
11006       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11007     } catch (std::out_of_range& e) {
11008       {
11009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11010       };
11011     } catch (std::exception& e) {
11012       {
11013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11014       };
11015     } catch (Dali::DaliException e) {
11016       {
11017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11018       };
11019     } catch (...) {
11020       {
11021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11022       };
11023     }
11024   }
11025
11026   jresult = result;
11027   return jresult;
11028 }
11029
11030
11031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11032   unsigned int jresult ;
11033   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11034   Dali::Vector3 *arg2 = 0 ;
11035   Dali::Radian *arg3 = 0 ;
11036   bool result;
11037
11038   arg1 = (Dali::Quaternion *)jarg1;
11039   arg2 = (Dali::Vector3 *)jarg2;
11040   if (!arg2) {
11041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11042     return 0;
11043   }
11044   arg3 = (Dali::Radian *)jarg3;
11045   if (!arg3) {
11046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11047     return 0;
11048   }
11049   {
11050     try {
11051       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11052     } catch (std::out_of_range& e) {
11053       {
11054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11055       };
11056     } catch (std::exception& e) {
11057       {
11058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11059       };
11060     } catch (Dali::DaliException e) {
11061       {
11062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11063       };
11064     } catch (...) {
11065       {
11066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11067       };
11068     }
11069   }
11070
11071   jresult = result;
11072   return jresult;
11073 }
11074
11075
11076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11077   void * jresult ;
11078   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11079   Dali::Quaternion *arg2 = 0 ;
11080   Dali::Quaternion result;
11081
11082   arg1 = (Dali::Quaternion *)jarg1;
11083   arg2 = (Dali::Quaternion *)jarg2;
11084   if (!arg2) {
11085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11086     return 0;
11087   }
11088   {
11089     try {
11090       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11091     } catch (std::out_of_range& e) {
11092       {
11093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11094       };
11095     } catch (std::exception& e) {
11096       {
11097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11098       };
11099     } catch (Dali::DaliException e) {
11100       {
11101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11102       };
11103     } catch (...) {
11104       {
11105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11106       };
11107     }
11108   }
11109
11110   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11111   return jresult;
11112 }
11113
11114
11115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11116   void * jresult ;
11117   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11118   Dali::Quaternion *arg2 = 0 ;
11119   Dali::Quaternion result;
11120
11121   arg1 = (Dali::Quaternion *)jarg1;
11122   arg2 = (Dali::Quaternion *)jarg2;
11123   if (!arg2) {
11124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11125     return 0;
11126   }
11127   {
11128     try {
11129       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11130     } catch (std::out_of_range& e) {
11131       {
11132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11133       };
11134     } catch (std::exception& e) {
11135       {
11136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11137       };
11138     } catch (Dali::DaliException e) {
11139       {
11140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11141       };
11142     } catch (...) {
11143       {
11144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11145       };
11146     }
11147   }
11148
11149   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11150   return jresult;
11151 }
11152
11153
11154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11155   void * jresult ;
11156   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11157   Dali::Quaternion *arg2 = 0 ;
11158   Dali::Quaternion result;
11159
11160   arg1 = (Dali::Quaternion *)jarg1;
11161   arg2 = (Dali::Quaternion *)jarg2;
11162   if (!arg2) {
11163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11164     return 0;
11165   }
11166   {
11167     try {
11168       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11169     } catch (std::out_of_range& e) {
11170       {
11171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11172       };
11173     } catch (std::exception& e) {
11174       {
11175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11176       };
11177     } catch (Dali::DaliException e) {
11178       {
11179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11180       };
11181     } catch (...) {
11182       {
11183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11184       };
11185     }
11186   }
11187
11188   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11189   return jresult;
11190 }
11191
11192
11193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11194   void * jresult ;
11195   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11196   Dali::Vector3 *arg2 = 0 ;
11197   Dali::Vector3 result;
11198
11199   arg1 = (Dali::Quaternion *)jarg1;
11200   arg2 = (Dali::Vector3 *)jarg2;
11201   if (!arg2) {
11202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11203     return 0;
11204   }
11205   {
11206     try {
11207       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11208     } catch (std::out_of_range& e) {
11209       {
11210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11211       };
11212     } catch (std::exception& e) {
11213       {
11214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11215       };
11216     } catch (Dali::DaliException e) {
11217       {
11218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11219       };
11220     } catch (...) {
11221       {
11222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11223       };
11224     }
11225   }
11226
11227   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11228   return jresult;
11229 }
11230
11231
11232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11233   void * jresult ;
11234   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11235   Dali::Quaternion *arg2 = 0 ;
11236   Dali::Quaternion result;
11237
11238   arg1 = (Dali::Quaternion *)jarg1;
11239   arg2 = (Dali::Quaternion *)jarg2;
11240   if (!arg2) {
11241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11242     return 0;
11243   }
11244   {
11245     try {
11246       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11247     } catch (std::out_of_range& e) {
11248       {
11249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11250       };
11251     } catch (std::exception& e) {
11252       {
11253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11254       };
11255     } catch (Dali::DaliException e) {
11256       {
11257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11258       };
11259     } catch (...) {
11260       {
11261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11262       };
11263     }
11264   }
11265
11266   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11267   return jresult;
11268 }
11269
11270
11271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11272   void * jresult ;
11273   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11274   float arg2 ;
11275   Dali::Quaternion result;
11276
11277   arg1 = (Dali::Quaternion *)jarg1;
11278   arg2 = (float)jarg2;
11279   {
11280     try {
11281       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11282     } catch (std::out_of_range& e) {
11283       {
11284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11285       };
11286     } catch (std::exception& e) {
11287       {
11288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11289       };
11290     } catch (Dali::DaliException e) {
11291       {
11292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11293       };
11294     } catch (...) {
11295       {
11296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11297       };
11298     }
11299   }
11300
11301   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11302   return jresult;
11303 }
11304
11305
11306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11307   void * jresult ;
11308   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11309   float arg2 ;
11310   Dali::Quaternion result;
11311
11312   arg1 = (Dali::Quaternion *)jarg1;
11313   arg2 = (float)jarg2;
11314   {
11315     try {
11316       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11317     } catch (std::out_of_range& e) {
11318       {
11319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11320       };
11321     } catch (std::exception& e) {
11322       {
11323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11324       };
11325     } catch (Dali::DaliException e) {
11326       {
11327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11328       };
11329     } catch (...) {
11330       {
11331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11332       };
11333     }
11334   }
11335
11336   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11337   return jresult;
11338 }
11339
11340
11341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11342   void * jresult ;
11343   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11344   Dali::Quaternion result;
11345
11346   arg1 = (Dali::Quaternion *)jarg1;
11347   {
11348     try {
11349       result = ((Dali::Quaternion const *)arg1)->operator -();
11350     } catch (std::out_of_range& e) {
11351       {
11352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11353       };
11354     } catch (std::exception& e) {
11355       {
11356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11357       };
11358     } catch (Dali::DaliException e) {
11359       {
11360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11361       };
11362     } catch (...) {
11363       {
11364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11365       };
11366     }
11367   }
11368
11369   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11370   return jresult;
11371 }
11372
11373
11374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11375   void * jresult ;
11376   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11377   Dali::Quaternion *arg2 = 0 ;
11378   Dali::Quaternion *result = 0 ;
11379
11380   arg1 = (Dali::Quaternion *)jarg1;
11381   arg2 = (Dali::Quaternion *)jarg2;
11382   if (!arg2) {
11383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11384     return 0;
11385   }
11386   {
11387     try {
11388       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11389     } catch (std::out_of_range& e) {
11390       {
11391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11392       };
11393     } catch (std::exception& e) {
11394       {
11395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11396       };
11397     } catch (Dali::DaliException e) {
11398       {
11399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11400       };
11401     } catch (...) {
11402       {
11403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11404       };
11405     }
11406   }
11407
11408   jresult = (void *)result;
11409   return jresult;
11410 }
11411
11412
11413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11414   void * jresult ;
11415   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11416   Dali::Quaternion *arg2 = 0 ;
11417   Dali::Quaternion *result = 0 ;
11418
11419   arg1 = (Dali::Quaternion *)jarg1;
11420   arg2 = (Dali::Quaternion *)jarg2;
11421   if (!arg2) {
11422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11423     return 0;
11424   }
11425   {
11426     try {
11427       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11428     } catch (std::out_of_range& e) {
11429       {
11430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11431       };
11432     } catch (std::exception& e) {
11433       {
11434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11435       };
11436     } catch (Dali::DaliException e) {
11437       {
11438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11439       };
11440     } catch (...) {
11441       {
11442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11443       };
11444     }
11445   }
11446
11447   jresult = (void *)result;
11448   return jresult;
11449 }
11450
11451
11452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11453   void * jresult ;
11454   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11455   Dali::Quaternion *arg2 = 0 ;
11456   Dali::Quaternion *result = 0 ;
11457
11458   arg1 = (Dali::Quaternion *)jarg1;
11459   arg2 = (Dali::Quaternion *)jarg2;
11460   if (!arg2) {
11461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11462     return 0;
11463   }
11464   {
11465     try {
11466       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11467     } catch (std::out_of_range& e) {
11468       {
11469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11470       };
11471     } catch (std::exception& e) {
11472       {
11473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11474       };
11475     } catch (Dali::DaliException e) {
11476       {
11477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11478       };
11479     } catch (...) {
11480       {
11481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11482       };
11483     }
11484   }
11485
11486   jresult = (void *)result;
11487   return jresult;
11488 }
11489
11490
11491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11492   void * jresult ;
11493   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11494   float arg2 ;
11495   Dali::Quaternion *result = 0 ;
11496
11497   arg1 = (Dali::Quaternion *)jarg1;
11498   arg2 = (float)jarg2;
11499   {
11500     try {
11501       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11502     } catch (std::out_of_range& e) {
11503       {
11504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11505       };
11506     } catch (std::exception& e) {
11507       {
11508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11509       };
11510     } catch (Dali::DaliException e) {
11511       {
11512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11513       };
11514     } catch (...) {
11515       {
11516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11517       };
11518     }
11519   }
11520
11521   jresult = (void *)result;
11522   return jresult;
11523 }
11524
11525
11526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11527   void * jresult ;
11528   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11529   float arg2 ;
11530   Dali::Quaternion *result = 0 ;
11531
11532   arg1 = (Dali::Quaternion *)jarg1;
11533   arg2 = (float)jarg2;
11534   {
11535     try {
11536       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11537     } catch (std::out_of_range& e) {
11538       {
11539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11540       };
11541     } catch (std::exception& e) {
11542       {
11543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11544       };
11545     } catch (Dali::DaliException e) {
11546       {
11547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11548       };
11549     } catch (...) {
11550       {
11551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11552       };
11553     }
11554   }
11555
11556   jresult = (void *)result;
11557   return jresult;
11558 }
11559
11560
11561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11562   unsigned int jresult ;
11563   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11564   Dali::Quaternion *arg2 = 0 ;
11565   bool result;
11566
11567   arg1 = (Dali::Quaternion *)jarg1;
11568   arg2 = (Dali::Quaternion *)jarg2;
11569   if (!arg2) {
11570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11571     return 0;
11572   }
11573   {
11574     try {
11575       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11576     } catch (std::out_of_range& e) {
11577       {
11578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11579       };
11580     } catch (std::exception& e) {
11581       {
11582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11583       };
11584     } catch (Dali::DaliException e) {
11585       {
11586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11587       };
11588     } catch (...) {
11589       {
11590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11591       };
11592     }
11593   }
11594
11595   jresult = result;
11596   return jresult;
11597 }
11598
11599
11600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11601   unsigned int jresult ;
11602   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11603   Dali::Quaternion *arg2 = 0 ;
11604   bool result;
11605
11606   arg1 = (Dali::Quaternion *)jarg1;
11607   arg2 = (Dali::Quaternion *)jarg2;
11608   if (!arg2) {
11609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11610     return 0;
11611   }
11612   {
11613     try {
11614       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11615     } catch (std::out_of_range& e) {
11616       {
11617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11618       };
11619     } catch (std::exception& e) {
11620       {
11621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11622       };
11623     } catch (Dali::DaliException e) {
11624       {
11625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11626       };
11627     } catch (...) {
11628       {
11629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11630       };
11631     }
11632   }
11633
11634   jresult = result;
11635   return jresult;
11636 }
11637
11638
11639 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11640   float jresult ;
11641   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11642   float result;
11643
11644   arg1 = (Dali::Quaternion *)jarg1;
11645   {
11646     try {
11647       result = (float)((Dali::Quaternion const *)arg1)->Length();
11648     } catch (std::out_of_range& e) {
11649       {
11650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11651       };
11652     } catch (std::exception& e) {
11653       {
11654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11655       };
11656     } catch (Dali::DaliException e) {
11657       {
11658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11659       };
11660     } catch (...) {
11661       {
11662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11663       };
11664     }
11665   }
11666
11667   jresult = result;
11668   return jresult;
11669 }
11670
11671
11672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11673   float jresult ;
11674   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11675   float result;
11676
11677   arg1 = (Dali::Quaternion *)jarg1;
11678   {
11679     try {
11680       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11681     } catch (std::out_of_range& e) {
11682       {
11683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11684       };
11685     } catch (std::exception& e) {
11686       {
11687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11688       };
11689     } catch (Dali::DaliException e) {
11690       {
11691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11692       };
11693     } catch (...) {
11694       {
11695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11696       };
11697     }
11698   }
11699
11700   jresult = result;
11701   return jresult;
11702 }
11703
11704
11705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11706   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11707
11708   arg1 = (Dali::Quaternion *)jarg1;
11709   {
11710     try {
11711       (arg1)->Normalize();
11712     } catch (std::out_of_range& e) {
11713       {
11714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11715       };
11716     } catch (std::exception& e) {
11717       {
11718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11719       };
11720     } catch (Dali::DaliException e) {
11721       {
11722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11723       };
11724     } catch (...) {
11725       {
11726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11727       };
11728     }
11729   }
11730
11731 }
11732
11733
11734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11735   void * jresult ;
11736   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11737   Dali::Quaternion result;
11738
11739   arg1 = (Dali::Quaternion *)jarg1;
11740   {
11741     try {
11742       result = ((Dali::Quaternion const *)arg1)->Normalized();
11743     } catch (std::out_of_range& e) {
11744       {
11745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11746       };
11747     } catch (std::exception& e) {
11748       {
11749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11750       };
11751     } catch (Dali::DaliException e) {
11752       {
11753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11754       };
11755     } catch (...) {
11756       {
11757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11758       };
11759     }
11760   }
11761
11762   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11763   return jresult;
11764 }
11765
11766
11767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11768   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11769
11770   arg1 = (Dali::Quaternion *)jarg1;
11771   {
11772     try {
11773       (arg1)->Conjugate();
11774     } catch (std::out_of_range& e) {
11775       {
11776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11777       };
11778     } catch (std::exception& e) {
11779       {
11780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11781       };
11782     } catch (Dali::DaliException e) {
11783       {
11784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11785       };
11786     } catch (...) {
11787       {
11788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11789       };
11790     }
11791   }
11792
11793 }
11794
11795
11796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11797   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11798
11799   arg1 = (Dali::Quaternion *)jarg1;
11800   {
11801     try {
11802       (arg1)->Invert();
11803     } catch (std::out_of_range& e) {
11804       {
11805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11806       };
11807     } catch (std::exception& e) {
11808       {
11809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11810       };
11811     } catch (Dali::DaliException e) {
11812       {
11813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11814       };
11815     } catch (...) {
11816       {
11817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11818       };
11819     }
11820   }
11821
11822 }
11823
11824
11825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11826   void * jresult ;
11827   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11828   Dali::Quaternion result;
11829
11830   arg1 = (Dali::Quaternion *)jarg1;
11831   {
11832     try {
11833       result = ((Dali::Quaternion const *)arg1)->Log();
11834     } catch (std::out_of_range& e) {
11835       {
11836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11837       };
11838     } catch (std::exception& e) {
11839       {
11840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11841       };
11842     } catch (Dali::DaliException e) {
11843       {
11844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11845       };
11846     } catch (...) {
11847       {
11848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11849       };
11850     }
11851   }
11852
11853   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11854   return jresult;
11855 }
11856
11857
11858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11859   void * jresult ;
11860   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11861   Dali::Quaternion result;
11862
11863   arg1 = (Dali::Quaternion *)jarg1;
11864   {
11865     try {
11866       result = ((Dali::Quaternion const *)arg1)->Exp();
11867     } catch (std::out_of_range& e) {
11868       {
11869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11870       };
11871     } catch (std::exception& e) {
11872       {
11873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11874       };
11875     } catch (Dali::DaliException e) {
11876       {
11877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11878       };
11879     } catch (...) {
11880       {
11881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11882       };
11883     }
11884   }
11885
11886   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11887   return jresult;
11888 }
11889
11890
11891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11892   float jresult ;
11893   Dali::Quaternion *arg1 = 0 ;
11894   Dali::Quaternion *arg2 = 0 ;
11895   float result;
11896
11897   arg1 = (Dali::Quaternion *)jarg1;
11898   if (!arg1) {
11899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11900     return 0;
11901   }
11902   arg2 = (Dali::Quaternion *)jarg2;
11903   if (!arg2) {
11904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11905     return 0;
11906   }
11907   {
11908     try {
11909       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11910     } catch (std::out_of_range& e) {
11911       {
11912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11913       };
11914     } catch (std::exception& e) {
11915       {
11916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11917       };
11918     } catch (Dali::DaliException e) {
11919       {
11920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11921       };
11922     } catch (...) {
11923       {
11924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11925       };
11926     }
11927   }
11928
11929   jresult = result;
11930   return jresult;
11931 }
11932
11933
11934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11935   void * jresult ;
11936   Dali::Quaternion *arg1 = 0 ;
11937   Dali::Quaternion *arg2 = 0 ;
11938   float arg3 ;
11939   Dali::Quaternion result;
11940
11941   arg1 = (Dali::Quaternion *)jarg1;
11942   if (!arg1) {
11943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11944     return 0;
11945   }
11946   arg2 = (Dali::Quaternion *)jarg2;
11947   if (!arg2) {
11948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11949     return 0;
11950   }
11951   arg3 = (float)jarg3;
11952   {
11953     try {
11954       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11955     } catch (std::out_of_range& e) {
11956       {
11957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11958       };
11959     } catch (std::exception& e) {
11960       {
11961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11962       };
11963     } catch (Dali::DaliException e) {
11964       {
11965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11966       };
11967     } catch (...) {
11968       {
11969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11970       };
11971     }
11972   }
11973
11974   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11975   return jresult;
11976 }
11977
11978
11979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11980   void * jresult ;
11981   Dali::Quaternion *arg1 = 0 ;
11982   Dali::Quaternion *arg2 = 0 ;
11983   float arg3 ;
11984   Dali::Quaternion result;
11985
11986   arg1 = (Dali::Quaternion *)jarg1;
11987   if (!arg1) {
11988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11989     return 0;
11990   }
11991   arg2 = (Dali::Quaternion *)jarg2;
11992   if (!arg2) {
11993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11994     return 0;
11995   }
11996   arg3 = (float)jarg3;
11997   {
11998     try {
11999       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12000     } catch (std::out_of_range& e) {
12001       {
12002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12003       };
12004     } catch (std::exception& e) {
12005       {
12006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12007       };
12008     } catch (Dali::DaliException e) {
12009       {
12010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12011       };
12012     } catch (...) {
12013       {
12014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12015       };
12016     }
12017   }
12018
12019   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12020   return jresult;
12021 }
12022
12023
12024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12025   void * jresult ;
12026   Dali::Quaternion *arg1 = 0 ;
12027   Dali::Quaternion *arg2 = 0 ;
12028   float arg3 ;
12029   Dali::Quaternion result;
12030
12031   arg1 = (Dali::Quaternion *)jarg1;
12032   if (!arg1) {
12033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12034     return 0;
12035   }
12036   arg2 = (Dali::Quaternion *)jarg2;
12037   if (!arg2) {
12038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12039     return 0;
12040   }
12041   arg3 = (float)jarg3;
12042   {
12043     try {
12044       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12045     } catch (std::out_of_range& e) {
12046       {
12047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12048       };
12049     } catch (std::exception& e) {
12050       {
12051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12052       };
12053     } catch (Dali::DaliException e) {
12054       {
12055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12056       };
12057     } catch (...) {
12058       {
12059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12060       };
12061     }
12062   }
12063
12064   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12065   return jresult;
12066 }
12067
12068
12069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12070   void * jresult ;
12071   Dali::Quaternion *arg1 = 0 ;
12072   Dali::Quaternion *arg2 = 0 ;
12073   Dali::Quaternion *arg3 = 0 ;
12074   Dali::Quaternion *arg4 = 0 ;
12075   float arg5 ;
12076   Dali::Quaternion result;
12077
12078   arg1 = (Dali::Quaternion *)jarg1;
12079   if (!arg1) {
12080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12081     return 0;
12082   }
12083   arg2 = (Dali::Quaternion *)jarg2;
12084   if (!arg2) {
12085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12086     return 0;
12087   }
12088   arg3 = (Dali::Quaternion *)jarg3;
12089   if (!arg3) {
12090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12091     return 0;
12092   }
12093   arg4 = (Dali::Quaternion *)jarg4;
12094   if (!arg4) {
12095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12096     return 0;
12097   }
12098   arg5 = (float)jarg5;
12099   {
12100     try {
12101       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12102     } catch (std::out_of_range& e) {
12103       {
12104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12105       };
12106     } catch (std::exception& e) {
12107       {
12108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12109       };
12110     } catch (Dali::DaliException e) {
12111       {
12112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12113       };
12114     } catch (...) {
12115       {
12116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12117       };
12118     }
12119   }
12120
12121   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12122   return jresult;
12123 }
12124
12125
12126 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12127   float jresult ;
12128   Dali::Quaternion *arg1 = 0 ;
12129   Dali::Quaternion *arg2 = 0 ;
12130   float result;
12131
12132   arg1 = (Dali::Quaternion *)jarg1;
12133   if (!arg1) {
12134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12135     return 0;
12136   }
12137   arg2 = (Dali::Quaternion *)jarg2;
12138   if (!arg2) {
12139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12140     return 0;
12141   }
12142   {
12143     try {
12144       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12145     } catch (std::out_of_range& e) {
12146       {
12147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12148       };
12149     } catch (std::exception& e) {
12150       {
12151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12152       };
12153     } catch (Dali::DaliException e) {
12154       {
12155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12156       };
12157     } catch (...) {
12158       {
12159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12160       };
12161     }
12162   }
12163
12164   jresult = result;
12165   return jresult;
12166 }
12167
12168
12169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12170   void * jresult ;
12171   Dali::Matrix *result = 0 ;
12172
12173   {
12174     try {
12175       result = (Dali::Matrix *)new Dali::Matrix();
12176     } catch (std::out_of_range& e) {
12177       {
12178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12179       };
12180     } catch (std::exception& e) {
12181       {
12182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12183       };
12184     } catch (Dali::DaliException e) {
12185       {
12186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12187       };
12188     } catch (...) {
12189       {
12190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12191       };
12192     }
12193   }
12194
12195   jresult = (void *)result;
12196   return jresult;
12197 }
12198
12199
12200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12201   void * jresult ;
12202   bool arg1 ;
12203   Dali::Matrix *result = 0 ;
12204
12205   arg1 = jarg1 ? true : false;
12206   {
12207     try {
12208       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12209     } catch (std::out_of_range& e) {
12210       {
12211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12212       };
12213     } catch (std::exception& e) {
12214       {
12215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12216       };
12217     } catch (Dali::DaliException e) {
12218       {
12219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12220       };
12221     } catch (...) {
12222       {
12223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12224       };
12225     }
12226   }
12227
12228   jresult = (void *)result;
12229   return jresult;
12230 }
12231
12232
12233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12234   void * jresult ;
12235   float *arg1 = (float *) 0 ;
12236   Dali::Matrix *result = 0 ;
12237
12238   arg1 = jarg1;
12239   {
12240     try {
12241       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12242     } catch (std::out_of_range& e) {
12243       {
12244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12245       };
12246     } catch (std::exception& e) {
12247       {
12248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12249       };
12250     } catch (Dali::DaliException e) {
12251       {
12252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12253       };
12254     } catch (...) {
12255       {
12256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12257       };
12258     }
12259   }
12260
12261   jresult = (void *)result;
12262
12263
12264   return jresult;
12265 }
12266
12267
12268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12269   void * jresult ;
12270   Dali::Quaternion *arg1 = 0 ;
12271   Dali::Matrix *result = 0 ;
12272
12273   arg1 = (Dali::Quaternion *)jarg1;
12274   if (!arg1) {
12275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12276     return 0;
12277   }
12278   {
12279     try {
12280       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12281     } catch (std::out_of_range& e) {
12282       {
12283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12284       };
12285     } catch (std::exception& e) {
12286       {
12287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12288       };
12289     } catch (Dali::DaliException e) {
12290       {
12291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12292       };
12293     } catch (...) {
12294       {
12295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12296       };
12297     }
12298   }
12299
12300   jresult = (void *)result;
12301   return jresult;
12302 }
12303
12304
12305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12306   void * jresult ;
12307   Dali::Matrix *arg1 = 0 ;
12308   Dali::Matrix *result = 0 ;
12309
12310   arg1 = (Dali::Matrix *)jarg1;
12311   if (!arg1) {
12312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12313     return 0;
12314   }
12315   {
12316     try {
12317       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12318     } catch (std::out_of_range& e) {
12319       {
12320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12321       };
12322     } catch (std::exception& e) {
12323       {
12324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12325       };
12326     } catch (Dali::DaliException e) {
12327       {
12328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12329       };
12330     } catch (...) {
12331       {
12332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12333       };
12334     }
12335   }
12336
12337   jresult = (void *)result;
12338   return jresult;
12339 }
12340
12341
12342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12343   void * jresult ;
12344   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12345   Dali::Matrix *arg2 = 0 ;
12346   Dali::Matrix *result = 0 ;
12347
12348   arg1 = (Dali::Matrix *)jarg1;
12349   arg2 = (Dali::Matrix *)jarg2;
12350   if (!arg2) {
12351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12352     return 0;
12353   }
12354   {
12355     try {
12356       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12357     } catch (std::out_of_range& e) {
12358       {
12359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12360       };
12361     } catch (std::exception& e) {
12362       {
12363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12364       };
12365     } catch (Dali::DaliException e) {
12366       {
12367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12368       };
12369     } catch (...) {
12370       {
12371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12372       };
12373     }
12374   }
12375
12376   jresult = (void *)result;
12377   return jresult;
12378 }
12379
12380
12381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12382   void * jresult ;
12383   Dali::Matrix *result = 0 ;
12384
12385   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12386   jresult = (void *)result;
12387   return jresult;
12388 }
12389
12390
12391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12392   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12393
12394   arg1 = (Dali::Matrix *)jarg1;
12395   {
12396     try {
12397       (arg1)->SetIdentity();
12398     } catch (std::out_of_range& e) {
12399       {
12400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12401       };
12402     } catch (std::exception& e) {
12403       {
12404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12405       };
12406     } catch (Dali::DaliException e) {
12407       {
12408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12409       };
12410     } catch (...) {
12411       {
12412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12413       };
12414     }
12415   }
12416
12417 }
12418
12419
12420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12421   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12422   Dali::Vector3 *arg2 = 0 ;
12423
12424   arg1 = (Dali::Matrix *)jarg1;
12425   arg2 = (Dali::Vector3 *)jarg2;
12426   if (!arg2) {
12427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12428     return ;
12429   }
12430   {
12431     try {
12432       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12433     } catch (std::out_of_range& e) {
12434       {
12435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12436       };
12437     } catch (std::exception& e) {
12438       {
12439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12440       };
12441     } catch (Dali::DaliException e) {
12442       {
12443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12444       };
12445     } catch (...) {
12446       {
12447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12448       };
12449     }
12450   }
12451
12452 }
12453
12454
12455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12456   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12457   Dali::Matrix *arg2 = 0 ;
12458
12459   arg1 = (Dali::Matrix *)jarg1;
12460   arg2 = (Dali::Matrix *)jarg2;
12461   if (!arg2) {
12462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12463     return ;
12464   }
12465   {
12466     try {
12467       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12468     } catch (std::out_of_range& e) {
12469       {
12470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12471       };
12472     } catch (std::exception& e) {
12473       {
12474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12475       };
12476     } catch (Dali::DaliException e) {
12477       {
12478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12479       };
12480     } catch (...) {
12481       {
12482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12483       };
12484     }
12485   }
12486
12487 }
12488
12489
12490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12491   unsigned int jresult ;
12492   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12493   bool result;
12494
12495   arg1 = (Dali::Matrix *)jarg1;
12496   {
12497     try {
12498       result = (bool)(arg1)->Invert();
12499     } catch (std::out_of_range& e) {
12500       {
12501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12502       };
12503     } catch (std::exception& e) {
12504       {
12505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12506       };
12507     } catch (Dali::DaliException e) {
12508       {
12509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12510       };
12511     } catch (...) {
12512       {
12513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12514       };
12515     }
12516   }
12517
12518   jresult = result;
12519   return jresult;
12520 }
12521
12522
12523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12524   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12525
12526   arg1 = (Dali::Matrix *)jarg1;
12527   {
12528     try {
12529       (arg1)->Transpose();
12530     } catch (std::out_of_range& e) {
12531       {
12532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12533       };
12534     } catch (std::exception& e) {
12535       {
12536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12537       };
12538     } catch (Dali::DaliException e) {
12539       {
12540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12541       };
12542     } catch (...) {
12543       {
12544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12545       };
12546     }
12547   }
12548
12549 }
12550
12551
12552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12553   void * jresult ;
12554   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12555   Dali::Vector3 result;
12556
12557   arg1 = (Dali::Matrix *)jarg1;
12558   {
12559     try {
12560       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12561     } catch (std::out_of_range& e) {
12562       {
12563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12564       };
12565     } catch (std::exception& e) {
12566       {
12567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12568       };
12569     } catch (Dali::DaliException e) {
12570       {
12571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12572       };
12573     } catch (...) {
12574       {
12575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12576       };
12577     }
12578   }
12579
12580   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12581   return jresult;
12582 }
12583
12584
12585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12586   void * jresult ;
12587   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12588   Dali::Vector3 result;
12589
12590   arg1 = (Dali::Matrix *)jarg1;
12591   {
12592     try {
12593       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12594     } catch (std::out_of_range& e) {
12595       {
12596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12597       };
12598     } catch (std::exception& e) {
12599       {
12600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12601       };
12602     } catch (Dali::DaliException e) {
12603       {
12604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12605       };
12606     } catch (...) {
12607       {
12608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12609       };
12610     }
12611   }
12612
12613   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12614   return jresult;
12615 }
12616
12617
12618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12619   void * jresult ;
12620   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12621   Dali::Vector3 result;
12622
12623   arg1 = (Dali::Matrix *)jarg1;
12624   {
12625     try {
12626       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12627     } catch (std::out_of_range& e) {
12628       {
12629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12630       };
12631     } catch (std::exception& e) {
12632       {
12633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12634       };
12635     } catch (Dali::DaliException e) {
12636       {
12637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12638       };
12639     } catch (...) {
12640       {
12641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12642       };
12643     }
12644   }
12645
12646   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12647   return jresult;
12648 }
12649
12650
12651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12652   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12653   Dali::Vector3 *arg2 = 0 ;
12654
12655   arg1 = (Dali::Matrix *)jarg1;
12656   arg2 = (Dali::Vector3 *)jarg2;
12657   if (!arg2) {
12658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12659     return ;
12660   }
12661   {
12662     try {
12663       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12664     } catch (std::out_of_range& e) {
12665       {
12666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12667       };
12668     } catch (std::exception& e) {
12669       {
12670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12671       };
12672     } catch (Dali::DaliException e) {
12673       {
12674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12675       };
12676     } catch (...) {
12677       {
12678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12679       };
12680     }
12681   }
12682
12683 }
12684
12685
12686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12687   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12688   Dali::Vector3 *arg2 = 0 ;
12689
12690   arg1 = (Dali::Matrix *)jarg1;
12691   arg2 = (Dali::Vector3 *)jarg2;
12692   if (!arg2) {
12693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12694     return ;
12695   }
12696   {
12697     try {
12698       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12699     } catch (std::out_of_range& e) {
12700       {
12701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12702       };
12703     } catch (std::exception& e) {
12704       {
12705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12706       };
12707     } catch (Dali::DaliException e) {
12708       {
12709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12710       };
12711     } catch (...) {
12712       {
12713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12714       };
12715     }
12716   }
12717
12718 }
12719
12720
12721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12722   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12723   Dali::Vector3 *arg2 = 0 ;
12724
12725   arg1 = (Dali::Matrix *)jarg1;
12726   arg2 = (Dali::Vector3 *)jarg2;
12727   if (!arg2) {
12728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12729     return ;
12730   }
12731   {
12732     try {
12733       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12734     } catch (std::out_of_range& e) {
12735       {
12736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12737       };
12738     } catch (std::exception& e) {
12739       {
12740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12741       };
12742     } catch (Dali::DaliException e) {
12743       {
12744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12745       };
12746     } catch (...) {
12747       {
12748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12749       };
12750     }
12751   }
12752
12753 }
12754
12755
12756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12757   void * jresult ;
12758   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12759   Dali::Vector4 *result = 0 ;
12760
12761   arg1 = (Dali::Matrix *)jarg1;
12762   {
12763     try {
12764       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12765     } catch (std::out_of_range& e) {
12766       {
12767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12768       };
12769     } catch (std::exception& e) {
12770       {
12771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12772       };
12773     } catch (Dali::DaliException e) {
12774       {
12775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12776       };
12777     } catch (...) {
12778       {
12779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12780       };
12781     }
12782   }
12783
12784   jresult = (void *)result;
12785   return jresult;
12786 }
12787
12788
12789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12790   void * jresult ;
12791   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12792   Dali::Vector3 *result = 0 ;
12793
12794   arg1 = (Dali::Matrix *)jarg1;
12795   {
12796     try {
12797       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12798     } catch (std::out_of_range& e) {
12799       {
12800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12801       };
12802     } catch (std::exception& e) {
12803       {
12804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12805       };
12806     } catch (Dali::DaliException e) {
12807       {
12808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12809       };
12810     } catch (...) {
12811       {
12812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12813       };
12814     }
12815   }
12816
12817   jresult = (void *)result;
12818   return jresult;
12819 }
12820
12821
12822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12823   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12824   Dali::Vector4 *arg2 = 0 ;
12825
12826   arg1 = (Dali::Matrix *)jarg1;
12827   arg2 = (Dali::Vector4 *)jarg2;
12828   if (!arg2) {
12829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12830     return ;
12831   }
12832   {
12833     try {
12834       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12835     } catch (std::out_of_range& e) {
12836       {
12837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12838       };
12839     } catch (std::exception& e) {
12840       {
12841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12842       };
12843     } catch (Dali::DaliException e) {
12844       {
12845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12846       };
12847     } catch (...) {
12848       {
12849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12850       };
12851     }
12852   }
12853
12854 }
12855
12856
12857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12858   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12859   Dali::Vector3 *arg2 = 0 ;
12860
12861   arg1 = (Dali::Matrix *)jarg1;
12862   arg2 = (Dali::Vector3 *)jarg2;
12863   if (!arg2) {
12864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12865     return ;
12866   }
12867   {
12868     try {
12869       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12870     } catch (std::out_of_range& e) {
12871       {
12872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12873       };
12874     } catch (std::exception& e) {
12875       {
12876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12877       };
12878     } catch (Dali::DaliException e) {
12879       {
12880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12881       };
12882     } catch (...) {
12883       {
12884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12885       };
12886     }
12887   }
12888
12889 }
12890
12891
12892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12893   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12894
12895   arg1 = (Dali::Matrix *)jarg1;
12896   {
12897     try {
12898       (arg1)->OrthoNormalize();
12899     } catch (std::out_of_range& e) {
12900       {
12901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12902       };
12903     } catch (std::exception& e) {
12904       {
12905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12906       };
12907     } catch (Dali::DaliException e) {
12908       {
12909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12910       };
12911     } catch (...) {
12912       {
12913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12914       };
12915     }
12916   }
12917
12918 }
12919
12920
12921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12922   void * jresult ;
12923   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12924   float *result = 0 ;
12925
12926   arg1 = (Dali::Matrix *)jarg1;
12927   {
12928     try {
12929       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12930     } catch (std::out_of_range& e) {
12931       {
12932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12933       };
12934     } catch (std::exception& e) {
12935       {
12936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12937       };
12938     } catch (Dali::DaliException e) {
12939       {
12940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12941       };
12942     } catch (...) {
12943       {
12944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12945       };
12946     }
12947   }
12948
12949   jresult = (void *)result;
12950   return jresult;
12951 }
12952
12953
12954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12955   Dali::Matrix *arg1 = 0 ;
12956   Dali::Matrix *arg2 = 0 ;
12957   Dali::Matrix *arg3 = 0 ;
12958
12959   arg1 = (Dali::Matrix *)jarg1;
12960   if (!arg1) {
12961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12962     return ;
12963   }
12964   arg2 = (Dali::Matrix *)jarg2;
12965   if (!arg2) {
12966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12967     return ;
12968   }
12969   arg3 = (Dali::Matrix *)jarg3;
12970   if (!arg3) {
12971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12972     return ;
12973   }
12974   {
12975     try {
12976       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12977     } catch (std::out_of_range& e) {
12978       {
12979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12980       };
12981     } catch (std::exception& e) {
12982       {
12983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12984       };
12985     } catch (Dali::DaliException e) {
12986       {
12987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12988       };
12989     } catch (...) {
12990       {
12991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12992       };
12993     }
12994   }
12995
12996 }
12997
12998
12999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13000   Dali::Matrix *arg1 = 0 ;
13001   Dali::Matrix *arg2 = 0 ;
13002   Dali::Quaternion *arg3 = 0 ;
13003
13004   arg1 = (Dali::Matrix *)jarg1;
13005   if (!arg1) {
13006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13007     return ;
13008   }
13009   arg2 = (Dali::Matrix *)jarg2;
13010   if (!arg2) {
13011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13012     return ;
13013   }
13014   arg3 = (Dali::Quaternion *)jarg3;
13015   if (!arg3) {
13016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13017     return ;
13018   }
13019   {
13020     try {
13021       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13022     } catch (std::out_of_range& e) {
13023       {
13024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13025       };
13026     } catch (std::exception& e) {
13027       {
13028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13029       };
13030     } catch (Dali::DaliException e) {
13031       {
13032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13033       };
13034     } catch (...) {
13035       {
13036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13037       };
13038     }
13039   }
13040
13041 }
13042
13043
13044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13045   void * jresult ;
13046   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13047   Dali::Vector4 *arg2 = 0 ;
13048   Dali::Vector4 result;
13049
13050   arg1 = (Dali::Matrix *)jarg1;
13051   arg2 = (Dali::Vector4 *)jarg2;
13052   if (!arg2) {
13053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13054     return 0;
13055   }
13056   {
13057     try {
13058       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13059     } catch (std::out_of_range& e) {
13060       {
13061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13062       };
13063     } catch (std::exception& e) {
13064       {
13065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13066       };
13067     } catch (Dali::DaliException e) {
13068       {
13069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13070       };
13071     } catch (...) {
13072       {
13073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13074       };
13075     }
13076   }
13077
13078   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13079   return jresult;
13080 }
13081
13082
13083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13084   unsigned int jresult ;
13085   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13086   Dali::Matrix *arg2 = 0 ;
13087   bool result;
13088
13089   arg1 = (Dali::Matrix *)jarg1;
13090   arg2 = (Dali::Matrix *)jarg2;
13091   if (!arg2) {
13092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13093     return 0;
13094   }
13095   {
13096     try {
13097       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13098     } catch (std::out_of_range& e) {
13099       {
13100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13101       };
13102     } catch (std::exception& e) {
13103       {
13104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13105       };
13106     } catch (Dali::DaliException e) {
13107       {
13108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13109       };
13110     } catch (...) {
13111       {
13112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13113       };
13114     }
13115   }
13116
13117   jresult = result;
13118   return jresult;
13119 }
13120
13121
13122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13123   unsigned int jresult ;
13124   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13125   Dali::Matrix *arg2 = 0 ;
13126   bool result;
13127
13128   arg1 = (Dali::Matrix *)jarg1;
13129   arg2 = (Dali::Matrix *)jarg2;
13130   if (!arg2) {
13131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13132     return 0;
13133   }
13134   {
13135     try {
13136       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13137     } catch (std::out_of_range& e) {
13138       {
13139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13140       };
13141     } catch (std::exception& e) {
13142       {
13143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13144       };
13145     } catch (Dali::DaliException e) {
13146       {
13147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13148       };
13149     } catch (...) {
13150       {
13151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13152       };
13153     }
13154   }
13155
13156   jresult = result;
13157   return jresult;
13158 }
13159
13160
13161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13162   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13163   Dali::Vector3 *arg2 = 0 ;
13164   Dali::Quaternion *arg3 = 0 ;
13165   Dali::Vector3 *arg4 = 0 ;
13166
13167   arg1 = (Dali::Matrix *)jarg1;
13168   arg2 = (Dali::Vector3 *)jarg2;
13169   if (!arg2) {
13170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13171     return ;
13172   }
13173   arg3 = (Dali::Quaternion *)jarg3;
13174   if (!arg3) {
13175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13176     return ;
13177   }
13178   arg4 = (Dali::Vector3 *)jarg4;
13179   if (!arg4) {
13180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13181     return ;
13182   }
13183   {
13184     try {
13185       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13186     } catch (std::out_of_range& e) {
13187       {
13188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13189       };
13190     } catch (std::exception& e) {
13191       {
13192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13193       };
13194     } catch (Dali::DaliException e) {
13195       {
13196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13197       };
13198     } catch (...) {
13199       {
13200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13201       };
13202     }
13203   }
13204
13205 }
13206
13207
13208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13209   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13210   Dali::Vector3 *arg2 = 0 ;
13211   Dali::Quaternion *arg3 = 0 ;
13212   Dali::Vector3 *arg4 = 0 ;
13213
13214   arg1 = (Dali::Matrix *)jarg1;
13215   arg2 = (Dali::Vector3 *)jarg2;
13216   if (!arg2) {
13217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13218     return ;
13219   }
13220   arg3 = (Dali::Quaternion *)jarg3;
13221   if (!arg3) {
13222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13223     return ;
13224   }
13225   arg4 = (Dali::Vector3 *)jarg4;
13226   if (!arg4) {
13227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13228     return ;
13229   }
13230   {
13231     try {
13232       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13233     } catch (std::out_of_range& e) {
13234       {
13235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13236       };
13237     } catch (std::exception& e) {
13238       {
13239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13240       };
13241     } catch (Dali::DaliException e) {
13242       {
13243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13244       };
13245     } catch (...) {
13246       {
13247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13248       };
13249     }
13250   }
13251
13252 }
13253
13254
13255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13256   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13257   Dali::Vector3 *arg2 = 0 ;
13258   Dali::Vector3 *arg3 = 0 ;
13259   Dali::Vector3 *arg4 = 0 ;
13260   Dali::Vector3 *arg5 = 0 ;
13261
13262   arg1 = (Dali::Matrix *)jarg1;
13263   arg2 = (Dali::Vector3 *)jarg2;
13264   if (!arg2) {
13265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13266     return ;
13267   }
13268   arg3 = (Dali::Vector3 *)jarg3;
13269   if (!arg3) {
13270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13271     return ;
13272   }
13273   arg4 = (Dali::Vector3 *)jarg4;
13274   if (!arg4) {
13275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13276     return ;
13277   }
13278   arg5 = (Dali::Vector3 *)jarg5;
13279   if (!arg5) {
13280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13281     return ;
13282   }
13283   {
13284     try {
13285       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13286     } catch (std::out_of_range& e) {
13287       {
13288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13289       };
13290     } catch (std::exception& e) {
13291       {
13292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13293       };
13294     } catch (Dali::DaliException e) {
13295       {
13296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13297       };
13298     } catch (...) {
13299       {
13300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13301       };
13302     }
13303   }
13304
13305 }
13306
13307
13308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13309   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13310   Dali::Vector3 *arg2 = 0 ;
13311   Dali::Quaternion *arg3 = 0 ;
13312   Dali::Vector3 *arg4 = 0 ;
13313
13314   arg1 = (Dali::Matrix *)jarg1;
13315   arg2 = (Dali::Vector3 *)jarg2;
13316   if (!arg2) {
13317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13318     return ;
13319   }
13320   arg3 = (Dali::Quaternion *)jarg3;
13321   if (!arg3) {
13322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13323     return ;
13324   }
13325   arg4 = (Dali::Vector3 *)jarg4;
13326   if (!arg4) {
13327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13328     return ;
13329   }
13330   {
13331     try {
13332       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13333     } catch (std::out_of_range& e) {
13334       {
13335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13336       };
13337     } catch (std::exception& e) {
13338       {
13339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13340       };
13341     } catch (Dali::DaliException e) {
13342       {
13343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13344       };
13345     } catch (...) {
13346       {
13347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13348       };
13349     }
13350   }
13351
13352 }
13353
13354
13355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13356   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13357
13358   arg1 = (Dali::Matrix *)jarg1;
13359   {
13360     try {
13361       delete arg1;
13362     } catch (std::out_of_range& e) {
13363       {
13364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13365       };
13366     } catch (std::exception& e) {
13367       {
13368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13369       };
13370     } catch (Dali::DaliException e) {
13371       {
13372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13373       };
13374     } catch (...) {
13375       {
13376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13377       };
13378     }
13379   }
13380
13381 }
13382
13383
13384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13385   void * jresult ;
13386   Dali::Matrix3 *result = 0 ;
13387
13388   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13389   jresult = (void *)result;
13390   return jresult;
13391 }
13392
13393
13394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13395   void * jresult ;
13396   Dali::Matrix3 *result = 0 ;
13397
13398   {
13399     try {
13400       result = (Dali::Matrix3 *)new Dali::Matrix3();
13401     } catch (std::out_of_range& e) {
13402       {
13403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13404       };
13405     } catch (std::exception& e) {
13406       {
13407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13408       };
13409     } catch (Dali::DaliException e) {
13410       {
13411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13412       };
13413     } catch (...) {
13414       {
13415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13416       };
13417     }
13418   }
13419
13420   jresult = (void *)result;
13421   return jresult;
13422 }
13423
13424
13425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13426   void * jresult ;
13427   Dali::Matrix3 *arg1 = 0 ;
13428   Dali::Matrix3 *result = 0 ;
13429
13430   arg1 = (Dali::Matrix3 *)jarg1;
13431   if (!arg1) {
13432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13433     return 0;
13434   }
13435   {
13436     try {
13437       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13438     } catch (std::out_of_range& e) {
13439       {
13440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13441       };
13442     } catch (std::exception& e) {
13443       {
13444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13445       };
13446     } catch (Dali::DaliException e) {
13447       {
13448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13449       };
13450     } catch (...) {
13451       {
13452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13453       };
13454     }
13455   }
13456
13457   jresult = (void *)result;
13458   return jresult;
13459 }
13460
13461
13462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13463   void * jresult ;
13464   Dali::Matrix *arg1 = 0 ;
13465   Dali::Matrix3 *result = 0 ;
13466
13467   arg1 = (Dali::Matrix *)jarg1;
13468   if (!arg1) {
13469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13470     return 0;
13471   }
13472   {
13473     try {
13474       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13475     } catch (std::out_of_range& e) {
13476       {
13477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13478       };
13479     } catch (std::exception& e) {
13480       {
13481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13482       };
13483     } catch (Dali::DaliException e) {
13484       {
13485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13486       };
13487     } catch (...) {
13488       {
13489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13490       };
13491     }
13492   }
13493
13494   jresult = (void *)result;
13495   return jresult;
13496 }
13497
13498
13499 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) {
13500   void * jresult ;
13501   float arg1 ;
13502   float arg2 ;
13503   float arg3 ;
13504   float arg4 ;
13505   float arg5 ;
13506   float arg6 ;
13507   float arg7 ;
13508   float arg8 ;
13509   float arg9 ;
13510   Dali::Matrix3 *result = 0 ;
13511
13512   arg1 = (float)jarg1;
13513   arg2 = (float)jarg2;
13514   arg3 = (float)jarg3;
13515   arg4 = (float)jarg4;
13516   arg5 = (float)jarg5;
13517   arg6 = (float)jarg6;
13518   arg7 = (float)jarg7;
13519   arg8 = (float)jarg8;
13520   arg9 = (float)jarg9;
13521   {
13522     try {
13523       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13524     } catch (std::out_of_range& e) {
13525       {
13526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13527       };
13528     } catch (std::exception& e) {
13529       {
13530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13531       };
13532     } catch (Dali::DaliException e) {
13533       {
13534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13535       };
13536     } catch (...) {
13537       {
13538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13539       };
13540     }
13541   }
13542
13543   jresult = (void *)result;
13544   return jresult;
13545 }
13546
13547
13548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13549   void * jresult ;
13550   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13551   Dali::Matrix3 *arg2 = 0 ;
13552   Dali::Matrix3 *result = 0 ;
13553
13554   arg1 = (Dali::Matrix3 *)jarg1;
13555   arg2 = (Dali::Matrix3 *)jarg2;
13556   if (!arg2) {
13557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13558     return 0;
13559   }
13560   {
13561     try {
13562       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13563     } catch (std::out_of_range& e) {
13564       {
13565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13566       };
13567     } catch (std::exception& e) {
13568       {
13569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13570       };
13571     } catch (Dali::DaliException e) {
13572       {
13573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13574       };
13575     } catch (...) {
13576       {
13577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13578       };
13579     }
13580   }
13581
13582   jresult = (void *)result;
13583   return jresult;
13584 }
13585
13586
13587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13588   void * jresult ;
13589   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13590   Dali::Matrix *arg2 = 0 ;
13591   Dali::Matrix3 *result = 0 ;
13592
13593   arg1 = (Dali::Matrix3 *)jarg1;
13594   arg2 = (Dali::Matrix *)jarg2;
13595   if (!arg2) {
13596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13597     return 0;
13598   }
13599   {
13600     try {
13601       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13602     } catch (std::out_of_range& e) {
13603       {
13604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13605       };
13606     } catch (std::exception& e) {
13607       {
13608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13609       };
13610     } catch (Dali::DaliException e) {
13611       {
13612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13613       };
13614     } catch (...) {
13615       {
13616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13617       };
13618     }
13619   }
13620
13621   jresult = (void *)result;
13622   return jresult;
13623 }
13624
13625
13626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13627   unsigned int jresult ;
13628   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13629   Dali::Matrix3 *arg2 = 0 ;
13630   bool result;
13631
13632   arg1 = (Dali::Matrix3 *)jarg1;
13633   arg2 = (Dali::Matrix3 *)jarg2;
13634   if (!arg2) {
13635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13636     return 0;
13637   }
13638   {
13639     try {
13640       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13641     } catch (std::out_of_range& e) {
13642       {
13643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13644       };
13645     } catch (std::exception& e) {
13646       {
13647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13648       };
13649     } catch (Dali::DaliException e) {
13650       {
13651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13652       };
13653     } catch (...) {
13654       {
13655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13656       };
13657     }
13658   }
13659
13660   jresult = result;
13661   return jresult;
13662 }
13663
13664
13665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13666   unsigned int jresult ;
13667   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13668   Dali::Matrix3 *arg2 = 0 ;
13669   bool result;
13670
13671   arg1 = (Dali::Matrix3 *)jarg1;
13672   arg2 = (Dali::Matrix3 *)jarg2;
13673   if (!arg2) {
13674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13675     return 0;
13676   }
13677   {
13678     try {
13679       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13680     } catch (std::out_of_range& e) {
13681       {
13682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13683       };
13684     } catch (std::exception& e) {
13685       {
13686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13687       };
13688     } catch (Dali::DaliException e) {
13689       {
13690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13691       };
13692     } catch (...) {
13693       {
13694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13695       };
13696     }
13697   }
13698
13699   jresult = result;
13700   return jresult;
13701 }
13702
13703
13704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13705   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13706
13707   arg1 = (Dali::Matrix3 *)jarg1;
13708   {
13709     try {
13710       delete arg1;
13711     } catch (std::out_of_range& e) {
13712       {
13713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13714       };
13715     } catch (std::exception& e) {
13716       {
13717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13718       };
13719     } catch (Dali::DaliException e) {
13720       {
13721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13722       };
13723     } catch (...) {
13724       {
13725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13726       };
13727     }
13728   }
13729
13730 }
13731
13732
13733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13734   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13735
13736   arg1 = (Dali::Matrix3 *)jarg1;
13737   {
13738     try {
13739       (arg1)->SetIdentity();
13740     } catch (std::out_of_range& e) {
13741       {
13742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13743       };
13744     } catch (std::exception& e) {
13745       {
13746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13747       };
13748     } catch (Dali::DaliException e) {
13749       {
13750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13751       };
13752     } catch (...) {
13753       {
13754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13755       };
13756     }
13757   }
13758
13759 }
13760
13761
13762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13763   void * jresult ;
13764   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13765   float *result = 0 ;
13766
13767   arg1 = (Dali::Matrix3 *)jarg1;
13768   {
13769     try {
13770       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13771     } catch (std::out_of_range& e) {
13772       {
13773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13774       };
13775     } catch (std::exception& e) {
13776       {
13777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13778       };
13779     } catch (Dali::DaliException e) {
13780       {
13781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13782       };
13783     } catch (...) {
13784       {
13785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13786       };
13787     }
13788   }
13789
13790   jresult = (void *)result;
13791   return jresult;
13792 }
13793
13794
13795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13796   unsigned int jresult ;
13797   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13798   bool result;
13799
13800   arg1 = (Dali::Matrix3 *)jarg1;
13801   {
13802     try {
13803       result = (bool)(arg1)->Invert();
13804     } catch (std::out_of_range& e) {
13805       {
13806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13807       };
13808     } catch (std::exception& e) {
13809       {
13810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13811       };
13812     } catch (Dali::DaliException e) {
13813       {
13814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13815       };
13816     } catch (...) {
13817       {
13818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13819       };
13820     }
13821   }
13822
13823   jresult = result;
13824   return jresult;
13825 }
13826
13827
13828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13829   unsigned int jresult ;
13830   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13831   bool result;
13832
13833   arg1 = (Dali::Matrix3 *)jarg1;
13834   {
13835     try {
13836       result = (bool)(arg1)->Transpose();
13837     } catch (std::out_of_range& e) {
13838       {
13839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13840       };
13841     } catch (std::exception& e) {
13842       {
13843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13844       };
13845     } catch (Dali::DaliException e) {
13846       {
13847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13848       };
13849     } catch (...) {
13850       {
13851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13852       };
13853     }
13854   }
13855
13856   jresult = result;
13857   return jresult;
13858 }
13859
13860
13861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13862   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13863   float arg2 ;
13864
13865   arg1 = (Dali::Matrix3 *)jarg1;
13866   arg2 = (float)jarg2;
13867   {
13868     try {
13869       (arg1)->Scale(arg2);
13870     } catch (std::out_of_range& e) {
13871       {
13872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13873       };
13874     } catch (std::exception& e) {
13875       {
13876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13877       };
13878     } catch (Dali::DaliException e) {
13879       {
13880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13881       };
13882     } catch (...) {
13883       {
13884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13885       };
13886     }
13887   }
13888
13889 }
13890
13891
13892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13893   float jresult ;
13894   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13895   float result;
13896
13897   arg1 = (Dali::Matrix3 *)jarg1;
13898   {
13899     try {
13900       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13901     } catch (std::out_of_range& e) {
13902       {
13903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13904       };
13905     } catch (std::exception& e) {
13906       {
13907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13908       };
13909     } catch (Dali::DaliException e) {
13910       {
13911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13912       };
13913     } catch (...) {
13914       {
13915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13916       };
13917     }
13918   }
13919
13920   jresult = result;
13921   return jresult;
13922 }
13923
13924
13925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13926   unsigned int jresult ;
13927   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13928   bool result;
13929
13930   arg1 = (Dali::Matrix3 *)jarg1;
13931   {
13932     try {
13933       result = (bool)(arg1)->ScaledInverseTranspose();
13934     } catch (std::out_of_range& e) {
13935       {
13936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13937       };
13938     } catch (std::exception& e) {
13939       {
13940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13941       };
13942     } catch (Dali::DaliException e) {
13943       {
13944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13945       };
13946     } catch (...) {
13947       {
13948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13949       };
13950     }
13951   }
13952
13953   jresult = result;
13954   return jresult;
13955 }
13956
13957
13958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13959   Dali::Matrix3 *arg1 = 0 ;
13960   Dali::Matrix3 *arg2 = 0 ;
13961   Dali::Matrix3 *arg3 = 0 ;
13962
13963   arg1 = (Dali::Matrix3 *)jarg1;
13964   if (!arg1) {
13965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13966     return ;
13967   }
13968   arg2 = (Dali::Matrix3 *)jarg2;
13969   if (!arg2) {
13970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13971     return ;
13972   }
13973   arg3 = (Dali::Matrix3 *)jarg3;
13974   if (!arg3) {
13975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13976     return ;
13977   }
13978   {
13979     try {
13980       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13981     } catch (std::out_of_range& e) {
13982       {
13983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13984       };
13985     } catch (std::exception& e) {
13986       {
13987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13988       };
13989     } catch (Dali::DaliException e) {
13990       {
13991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13992       };
13993     } catch (...) {
13994       {
13995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13996       };
13997     }
13998   }
13999
14000 }
14001
14002
14003 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14004   float jresult ;
14005   float arg1 ;
14006   float arg2 ;
14007   float result;
14008
14009   arg1 = (float)jarg1;
14010   arg2 = (float)jarg2;
14011   {
14012     try {
14013       result = (float)Dali::Random::Range(arg1,arg2);
14014     } catch (std::out_of_range& e) {
14015       {
14016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14017       };
14018     } catch (std::exception& e) {
14019       {
14020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14021       };
14022     } catch (Dali::DaliException e) {
14023       {
14024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14025       };
14026     } catch (...) {
14027       {
14028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14029       };
14030     }
14031   }
14032
14033   jresult = result;
14034   return jresult;
14035 }
14036
14037
14038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14039   void * jresult ;
14040   Dali::Vector4 result;
14041
14042   {
14043     try {
14044       result = Dali::Random::Axis();
14045     } catch (std::out_of_range& e) {
14046       {
14047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14048       };
14049     } catch (std::exception& e) {
14050       {
14051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14052       };
14053     } catch (Dali::DaliException e) {
14054       {
14055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14056       };
14057     } catch (...) {
14058       {
14059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14060       };
14061     }
14062   }
14063
14064   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14065   return jresult;
14066 }
14067
14068
14069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14070   void * jresult ;
14071   Dali::AngleAxis *result = 0 ;
14072
14073   {
14074     try {
14075       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14076     } catch (std::out_of_range& e) {
14077       {
14078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14079       };
14080     } catch (std::exception& e) {
14081       {
14082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14083       };
14084     } catch (Dali::DaliException e) {
14085       {
14086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14087       };
14088     } catch (...) {
14089       {
14090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14091       };
14092     }
14093   }
14094
14095   jresult = (void *)result;
14096   return jresult;
14097 }
14098
14099
14100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14101   void * jresult ;
14102   Dali::Radian arg1 ;
14103   Dali::Vector3 *arg2 = 0 ;
14104   Dali::Radian *argp1 ;
14105   Dali::AngleAxis *result = 0 ;
14106
14107   argp1 = (Dali::Radian *)jarg1;
14108   if (!argp1) {
14109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14110     return 0;
14111   }
14112   arg1 = *argp1;
14113   arg2 = (Dali::Vector3 *)jarg2;
14114   if (!arg2) {
14115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14116     return 0;
14117   }
14118   {
14119     try {
14120       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14121     } catch (std::out_of_range& e) {
14122       {
14123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14124       };
14125     } catch (std::exception& e) {
14126       {
14127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14128       };
14129     } catch (Dali::DaliException e) {
14130       {
14131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14132       };
14133     } catch (...) {
14134       {
14135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14136       };
14137     }
14138   }
14139
14140   jresult = (void *)result;
14141   return jresult;
14142 }
14143
14144
14145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14146   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14147   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14148
14149   arg1 = (Dali::AngleAxis *)jarg1;
14150   arg2 = (Dali::Radian *)jarg2;
14151   if (arg1) (arg1)->angle = *arg2;
14152 }
14153
14154
14155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14156   void * jresult ;
14157   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14158   Dali::Radian *result = 0 ;
14159
14160   arg1 = (Dali::AngleAxis *)jarg1;
14161   result = (Dali::Radian *)& ((arg1)->angle);
14162   jresult = (void *)result;
14163   return jresult;
14164 }
14165
14166
14167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14168   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14169   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14170
14171   arg1 = (Dali::AngleAxis *)jarg1;
14172   arg2 = (Dali::Vector3 *)jarg2;
14173   if (arg1) (arg1)->axis = *arg2;
14174 }
14175
14176
14177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14178   void * jresult ;
14179   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14180   Dali::Vector3 *result = 0 ;
14181
14182   arg1 = (Dali::AngleAxis *)jarg1;
14183   result = (Dali::Vector3 *)& ((arg1)->axis);
14184   jresult = (void *)result;
14185   return jresult;
14186 }
14187
14188
14189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14190   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14191
14192   arg1 = (Dali::AngleAxis *)jarg1;
14193   {
14194     try {
14195       delete arg1;
14196     } catch (std::out_of_range& e) {
14197       {
14198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14199       };
14200     } catch (std::exception& e) {
14201       {
14202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14203       };
14204     } catch (Dali::DaliException e) {
14205       {
14206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14207       };
14208     } catch (...) {
14209       {
14210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14211       };
14212     }
14213   }
14214
14215 }
14216
14217
14218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14219   unsigned int jresult ;
14220   Dali::AngleAxis *arg1 = 0 ;
14221   Dali::AngleAxis *arg2 = 0 ;
14222   bool result;
14223
14224   arg1 = (Dali::AngleAxis *)jarg1;
14225   if (!arg1) {
14226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14227     return 0;
14228   }
14229   arg2 = (Dali::AngleAxis *)jarg2;
14230   if (!arg2) {
14231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14232     return 0;
14233   }
14234   {
14235     try {
14236       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14237     } catch (std::out_of_range& e) {
14238       {
14239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14240       };
14241     } catch (std::exception& e) {
14242       {
14243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14244       };
14245     } catch (Dali::DaliException e) {
14246       {
14247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14248       };
14249     } catch (...) {
14250       {
14251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14252       };
14253     }
14254   }
14255
14256   jresult = result;
14257   return jresult;
14258 }
14259
14260
14261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14262   unsigned int jresult ;
14263   unsigned int arg1 ;
14264   unsigned int result;
14265
14266   arg1 = (unsigned int)jarg1;
14267   {
14268     try {
14269       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14270     } catch (std::out_of_range& e) {
14271       {
14272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14273       };
14274     } catch (std::exception& e) {
14275       {
14276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14277       };
14278     } catch (Dali::DaliException e) {
14279       {
14280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14281       };
14282     } catch (...) {
14283       {
14284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14285       };
14286     }
14287   }
14288
14289   jresult = result;
14290   return jresult;
14291 }
14292
14293
14294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14295   unsigned int jresult ;
14296   unsigned int arg1 ;
14297   bool result;
14298
14299   arg1 = (unsigned int)jarg1;
14300   {
14301     try {
14302       result = (bool)Dali::IsPowerOfTwo(arg1);
14303     } catch (std::out_of_range& e) {
14304       {
14305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14306       };
14307     } catch (std::exception& e) {
14308       {
14309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14310       };
14311     } catch (Dali::DaliException e) {
14312       {
14313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14314       };
14315     } catch (...) {
14316       {
14317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14318       };
14319     }
14320   }
14321
14322   jresult = result;
14323   return jresult;
14324 }
14325
14326
14327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14328   float jresult ;
14329   float arg1 ;
14330   float arg2 ;
14331   float result;
14332
14333   arg1 = (float)jarg1;
14334   arg2 = (float)jarg2;
14335   {
14336     try {
14337       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14338     } catch (std::out_of_range& e) {
14339       {
14340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14341       };
14342     } catch (std::exception& e) {
14343       {
14344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14345       };
14346     } catch (Dali::DaliException e) {
14347       {
14348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14349       };
14350     } catch (...) {
14351       {
14352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14353       };
14354     }
14355   }
14356
14357   jresult = result;
14358   return jresult;
14359 }
14360
14361
14362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14363   unsigned int jresult ;
14364   float arg1 ;
14365   bool result;
14366
14367   arg1 = (float)jarg1;
14368   {
14369     try {
14370       result = (bool)Dali::EqualsZero(arg1);
14371     } catch (std::out_of_range& e) {
14372       {
14373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14374       };
14375     } catch (std::exception& e) {
14376       {
14377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14378       };
14379     } catch (Dali::DaliException e) {
14380       {
14381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14382       };
14383     } catch (...) {
14384       {
14385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14386       };
14387     }
14388   }
14389
14390   jresult = result;
14391   return jresult;
14392 }
14393
14394
14395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14396   unsigned int jresult ;
14397   float arg1 ;
14398   float arg2 ;
14399   bool result;
14400
14401   arg1 = (float)jarg1;
14402   arg2 = (float)jarg2;
14403   {
14404     try {
14405       result = (bool)Dali::Equals(arg1,arg2);
14406     } catch (std::out_of_range& e) {
14407       {
14408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14409       };
14410     } catch (std::exception& e) {
14411       {
14412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14413       };
14414     } catch (Dali::DaliException e) {
14415       {
14416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14417       };
14418     } catch (...) {
14419       {
14420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14421       };
14422     }
14423   }
14424
14425   jresult = result;
14426   return jresult;
14427 }
14428
14429
14430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14431   unsigned int jresult ;
14432   float arg1 ;
14433   float arg2 ;
14434   float arg3 ;
14435   bool result;
14436
14437   arg1 = (float)jarg1;
14438   arg2 = (float)jarg2;
14439   arg3 = (float)jarg3;
14440   {
14441     try {
14442       result = (bool)Dali::Equals(arg1,arg2,arg3);
14443     } catch (std::out_of_range& e) {
14444       {
14445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14446       };
14447     } catch (std::exception& e) {
14448       {
14449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14450       };
14451     } catch (Dali::DaliException e) {
14452       {
14453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14454       };
14455     } catch (...) {
14456       {
14457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14458       };
14459     }
14460   }
14461
14462   jresult = result;
14463   return jresult;
14464 }
14465
14466
14467 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14468   float jresult ;
14469   float arg1 ;
14470   int arg2 ;
14471   float result;
14472
14473   arg1 = (float)jarg1;
14474   arg2 = (int)jarg2;
14475   {
14476     try {
14477       result = (float)Dali::Round(arg1,arg2);
14478     } catch (std::out_of_range& e) {
14479       {
14480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14481       };
14482     } catch (std::exception& e) {
14483       {
14484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14485       };
14486     } catch (Dali::DaliException e) {
14487       {
14488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14489       };
14490     } catch (...) {
14491       {
14492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14493       };
14494     }
14495   }
14496
14497   jresult = result;
14498   return jresult;
14499 }
14500
14501
14502 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14503   float jresult ;
14504   float arg1 ;
14505   float arg2 ;
14506   float arg3 ;
14507   float result;
14508
14509   arg1 = (float)jarg1;
14510   arg2 = (float)jarg2;
14511   arg3 = (float)jarg3;
14512   {
14513     try {
14514       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14515     } catch (std::out_of_range& e) {
14516       {
14517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14518       };
14519     } catch (std::exception& e) {
14520       {
14521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14522       };
14523     } catch (Dali::DaliException e) {
14524       {
14525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14526       };
14527     } catch (...) {
14528       {
14529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14530       };
14531     }
14532   }
14533
14534   jresult = result;
14535   return jresult;
14536 }
14537
14538
14539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14540   float jresult ;
14541   float arg1 ;
14542   float arg2 ;
14543   float arg3 ;
14544   float arg4 ;
14545   float result;
14546
14547   arg1 = (float)jarg1;
14548   arg2 = (float)jarg2;
14549   arg3 = (float)jarg3;
14550   arg4 = (float)jarg4;
14551   {
14552     try {
14553       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14554     } catch (std::out_of_range& e) {
14555       {
14556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14557       };
14558     } catch (std::exception& e) {
14559       {
14560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14561       };
14562     } catch (Dali::DaliException e) {
14563       {
14564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14565       };
14566     } catch (...) {
14567       {
14568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14569       };
14570     }
14571   }
14572
14573   jresult = result;
14574   return jresult;
14575 }
14576
14577
14578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14579   int jresult ;
14580   int result;
14581
14582   result = (int)(int)Dali::Property::INVALID_INDEX;
14583   jresult = result;
14584   return jresult;
14585 }
14586
14587
14588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14589   int jresult ;
14590   int result;
14591
14592   result = (int)(int)Dali::Property::INVALID_KEY;
14593   jresult = result;
14594   return jresult;
14595 }
14596
14597
14598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14599   int jresult ;
14600   int result;
14601
14602   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14603   jresult = result;
14604   return jresult;
14605 }
14606
14607
14608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14609   void * jresult ;
14610   Dali::Handle *arg1 = 0 ;
14611   Dali::Property::Index arg2 ;
14612   Dali::Property *result = 0 ;
14613
14614   arg1 = (Dali::Handle *)jarg1;
14615   if (!arg1) {
14616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14617     return 0;
14618   }
14619   arg2 = (Dali::Property::Index)jarg2;
14620   {
14621     try {
14622       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14623     } catch (std::out_of_range& e) {
14624       {
14625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14626       };
14627     } catch (std::exception& e) {
14628       {
14629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14630       };
14631     } catch (Dali::DaliException e) {
14632       {
14633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14634       };
14635     } catch (...) {
14636       {
14637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14638       };
14639     }
14640   }
14641
14642   jresult = (void *)result;
14643   return jresult;
14644 }
14645
14646
14647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14648   void * jresult ;
14649   Dali::Handle *arg1 = 0 ;
14650   Dali::Property::Index arg2 ;
14651   int arg3 ;
14652   Dali::Property *result = 0 ;
14653
14654   arg1 = (Dali::Handle *)jarg1;
14655   if (!arg1) {
14656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14657     return 0;
14658   }
14659   arg2 = (Dali::Property::Index)jarg2;
14660   arg3 = (int)jarg3;
14661   {
14662     try {
14663       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14664     } catch (std::out_of_range& e) {
14665       {
14666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14667       };
14668     } catch (std::exception& e) {
14669       {
14670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14671       };
14672     } catch (Dali::DaliException e) {
14673       {
14674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14675       };
14676     } catch (...) {
14677       {
14678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14679       };
14680     }
14681   }
14682
14683   jresult = (void *)result;
14684   return jresult;
14685 }
14686
14687
14688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14689   void * jresult ;
14690   Dali::Handle *arg1 = 0 ;
14691   std::string *arg2 = 0 ;
14692   Dali::Property *result = 0 ;
14693
14694   arg1 = (Dali::Handle *)jarg1;
14695   if (!arg1) {
14696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14697     return 0;
14698   }
14699   if (!jarg2) {
14700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14701     return 0;
14702   }
14703   std::string arg2_str(jarg2);
14704   arg2 = &arg2_str;
14705   {
14706     try {
14707       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14708     } catch (std::out_of_range& e) {
14709       {
14710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14711       };
14712     } catch (std::exception& e) {
14713       {
14714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14715       };
14716     } catch (Dali::DaliException e) {
14717       {
14718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14719       };
14720     } catch (...) {
14721       {
14722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14723       };
14724     }
14725   }
14726
14727   jresult = (void *)result;
14728
14729   //argout typemap for const std::string&
14730
14731   return jresult;
14732 }
14733
14734
14735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14736   void * jresult ;
14737   Dali::Handle *arg1 = 0 ;
14738   std::string *arg2 = 0 ;
14739   int arg3 ;
14740   Dali::Property *result = 0 ;
14741
14742   arg1 = (Dali::Handle *)jarg1;
14743   if (!arg1) {
14744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14745     return 0;
14746   }
14747   if (!jarg2) {
14748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14749     return 0;
14750   }
14751   std::string arg2_str(jarg2);
14752   arg2 = &arg2_str;
14753   arg3 = (int)jarg3;
14754   {
14755     try {
14756       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14757     } catch (std::out_of_range& e) {
14758       {
14759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14760       };
14761     } catch (std::exception& e) {
14762       {
14763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14764       };
14765     } catch (Dali::DaliException e) {
14766       {
14767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14768       };
14769     } catch (...) {
14770       {
14771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14772       };
14773     }
14774   }
14775
14776   jresult = (void *)result;
14777
14778   //argout typemap for const std::string&
14779
14780   return jresult;
14781 }
14782
14783
14784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14785   Dali::Property *arg1 = (Dali::Property *) 0 ;
14786
14787   arg1 = (Dali::Property *)jarg1;
14788   {
14789     try {
14790       delete arg1;
14791     } catch (std::out_of_range& e) {
14792       {
14793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14794       };
14795     } catch (std::exception& e) {
14796       {
14797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14798       };
14799     } catch (Dali::DaliException e) {
14800       {
14801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14802       };
14803     } catch (...) {
14804       {
14805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14806       };
14807     }
14808   }
14809
14810 }
14811
14812
14813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14814   Dali::Property *arg1 = (Dali::Property *) 0 ;
14815   Dali::Handle *arg2 = 0 ;
14816
14817   arg1 = (Dali::Property *)jarg1;
14818   arg2 = (Dali::Handle *)jarg2;
14819   if (!arg2) {
14820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14821     return ;
14822   }
14823   if (arg1) (arg1)->object = *arg2;
14824 }
14825
14826
14827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14828   void * jresult ;
14829   Dali::Property *arg1 = (Dali::Property *) 0 ;
14830   Dali::Handle *result = 0 ;
14831
14832   arg1 = (Dali::Property *)jarg1;
14833   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14834   jresult = (void *)result;
14835   return jresult;
14836 }
14837
14838
14839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14840   Dali::Property *arg1 = (Dali::Property *) 0 ;
14841   Dali::Property::Index arg2 ;
14842
14843   arg1 = (Dali::Property *)jarg1;
14844   arg2 = (Dali::Property::Index)jarg2;
14845   if (arg1) (arg1)->propertyIndex = arg2;
14846 }
14847
14848
14849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14850   int jresult ;
14851   Dali::Property *arg1 = (Dali::Property *) 0 ;
14852   Dali::Property::Index result;
14853
14854   arg1 = (Dali::Property *)jarg1;
14855   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14856   jresult = result;
14857   return jresult;
14858 }
14859
14860
14861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14862   Dali::Property *arg1 = (Dali::Property *) 0 ;
14863   int arg2 ;
14864
14865   arg1 = (Dali::Property *)jarg1;
14866   arg2 = (int)jarg2;
14867   if (arg1) (arg1)->componentIndex = arg2;
14868 }
14869
14870
14871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14872   int jresult ;
14873   Dali::Property *arg1 = (Dali::Property *) 0 ;
14874   int result;
14875
14876   arg1 = (Dali::Property *)jarg1;
14877   result = (int) ((arg1)->componentIndex);
14878   jresult = result;
14879   return jresult;
14880 }
14881
14882
14883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14884   void * jresult ;
14885   Dali::Property::Array *result = 0 ;
14886
14887   {
14888     try {
14889       result = (Dali::Property::Array *)new Dali::Property::Array();
14890     } catch (std::out_of_range& e) {
14891       {
14892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14893       };
14894     } catch (std::exception& e) {
14895       {
14896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14897       };
14898     } catch (Dali::DaliException e) {
14899       {
14900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14901       };
14902     } catch (...) {
14903       {
14904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14905       };
14906     }
14907   }
14908
14909   jresult = (void *)result;
14910   return jresult;
14911 }
14912
14913
14914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14915   void * jresult ;
14916   Dali::Property::Array *arg1 = 0 ;
14917   Dali::Property::Array *result = 0 ;
14918
14919   arg1 = (Dali::Property::Array *)jarg1;
14920   if (!arg1) {
14921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14922     return 0;
14923   }
14924   {
14925     try {
14926       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14927     } catch (std::out_of_range& e) {
14928       {
14929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14930       };
14931     } catch (std::exception& e) {
14932       {
14933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14934       };
14935     } catch (Dali::DaliException e) {
14936       {
14937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14938       };
14939     } catch (...) {
14940       {
14941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14942       };
14943     }
14944   }
14945
14946   jresult = (void *)result;
14947   return jresult;
14948 }
14949
14950
14951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14952   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14953
14954   arg1 = (Dali::Property::Array *)jarg1;
14955   {
14956     try {
14957       delete arg1;
14958     } catch (std::out_of_range& e) {
14959       {
14960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14961       };
14962     } catch (std::exception& e) {
14963       {
14964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14965       };
14966     } catch (Dali::DaliException e) {
14967       {
14968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14969       };
14970     } catch (...) {
14971       {
14972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14973       };
14974     }
14975   }
14976
14977 }
14978
14979
14980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14981   unsigned long jresult ;
14982   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14983   Dali::Property::Array::SizeType result;
14984
14985   arg1 = (Dali::Property::Array *)jarg1;
14986   {
14987     try {
14988       result = ((Dali::Property::Array const *)arg1)->Size();
14989     } catch (std::out_of_range& e) {
14990       {
14991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14992       };
14993     } catch (std::exception& e) {
14994       {
14995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14996       };
14997     } catch (Dali::DaliException e) {
14998       {
14999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15000       };
15001     } catch (...) {
15002       {
15003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15004       };
15005     }
15006   }
15007
15008   jresult = (unsigned long)result;
15009   return jresult;
15010 }
15011
15012
15013 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15014   unsigned long jresult ;
15015   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15016   Dali::Property::Array::SizeType result;
15017
15018   arg1 = (Dali::Property::Array *)jarg1;
15019   {
15020     try {
15021       result = ((Dali::Property::Array const *)arg1)->Count();
15022     } catch (std::out_of_range& e) {
15023       {
15024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15025       };
15026     } catch (std::exception& e) {
15027       {
15028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15029       };
15030     } catch (Dali::DaliException e) {
15031       {
15032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15033       };
15034     } catch (...) {
15035       {
15036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15037       };
15038     }
15039   }
15040
15041   jresult = (unsigned long)result;
15042   return jresult;
15043 }
15044
15045
15046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15047   unsigned int jresult ;
15048   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15049   bool result;
15050
15051   arg1 = (Dali::Property::Array *)jarg1;
15052   {
15053     try {
15054       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15055     } catch (std::out_of_range& e) {
15056       {
15057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15058       };
15059     } catch (std::exception& e) {
15060       {
15061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15062       };
15063     } catch (Dali::DaliException e) {
15064       {
15065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15066       };
15067     } catch (...) {
15068       {
15069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15070       };
15071     }
15072   }
15073
15074   jresult = result;
15075   return jresult;
15076 }
15077
15078
15079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15080   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15081
15082   arg1 = (Dali::Property::Array *)jarg1;
15083   {
15084     try {
15085       (arg1)->Clear();
15086     } catch (std::out_of_range& e) {
15087       {
15088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15089       };
15090     } catch (std::exception& e) {
15091       {
15092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15093       };
15094     } catch (Dali::DaliException e) {
15095       {
15096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15097       };
15098     } catch (...) {
15099       {
15100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15101       };
15102     }
15103   }
15104
15105 }
15106
15107
15108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15109   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15110   Dali::Property::Array::SizeType arg2 ;
15111
15112   arg1 = (Dali::Property::Array *)jarg1;
15113   arg2 = (Dali::Property::Array::SizeType)jarg2;
15114   {
15115     try {
15116       (arg1)->Reserve(arg2);
15117     } catch (std::out_of_range& e) {
15118       {
15119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15120       };
15121     } catch (std::exception& e) {
15122       {
15123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15124       };
15125     } catch (Dali::DaliException e) {
15126       {
15127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15128       };
15129     } catch (...) {
15130       {
15131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15132       };
15133     }
15134   }
15135
15136 }
15137
15138
15139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15140   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15141   Dali::Property::Array::SizeType arg2 ;
15142
15143   arg1 = (Dali::Property::Array *)jarg1;
15144   arg2 = (Dali::Property::Array::SizeType)jarg2;
15145   {
15146     try {
15147       (arg1)->Resize(arg2);
15148     } catch (std::out_of_range& e) {
15149       {
15150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15151       };
15152     } catch (std::exception& e) {
15153       {
15154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15155       };
15156     } catch (Dali::DaliException e) {
15157       {
15158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15159       };
15160     } catch (...) {
15161       {
15162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15163       };
15164     }
15165   }
15166
15167 }
15168
15169
15170 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15171   unsigned long jresult ;
15172   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15173   Dali::Property::Array::SizeType result;
15174
15175   arg1 = (Dali::Property::Array *)jarg1;
15176   {
15177     try {
15178       result = (arg1)->Capacity();
15179     } catch (std::out_of_range& e) {
15180       {
15181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15182       };
15183     } catch (std::exception& e) {
15184       {
15185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15186       };
15187     } catch (Dali::DaliException e) {
15188       {
15189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15190       };
15191     } catch (...) {
15192       {
15193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15194       };
15195     }
15196   }
15197
15198   jresult = (unsigned long)result;
15199   return jresult;
15200 }
15201
15202
15203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15204   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15205   Dali::Property::Value *arg2 = 0 ;
15206
15207   arg1 = (Dali::Property::Array *)jarg1;
15208   arg2 = (Dali::Property::Value *)jarg2;
15209   if (!arg2) {
15210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15211     return ;
15212   }
15213   {
15214     try {
15215       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15216     } catch (std::out_of_range& e) {
15217       {
15218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15219       };
15220     } catch (std::exception& e) {
15221       {
15222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15223       };
15224     } catch (Dali::DaliException e) {
15225       {
15226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15227       };
15228     } catch (...) {
15229       {
15230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15231       };
15232     }
15233   }
15234
15235 }
15236
15237
15238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15239   void * jresult ;
15240   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15241   Dali::Property::Value *arg2 = 0 ;
15242   Dali::Property::Array *result = 0 ;
15243
15244   arg1 = (Dali::Property::Array *)jarg1;
15245   arg2 = (Dali::Property::Value *)jarg2;
15246   if (!arg2) {
15247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15248     return 0;
15249   }
15250   {
15251     try {
15252       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15253     } catch (std::out_of_range& e) {
15254       {
15255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15256       };
15257     } catch (std::exception& e) {
15258       {
15259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15260       };
15261     } catch (Dali::DaliException e) {
15262       {
15263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15264       };
15265     } catch (...) {
15266       {
15267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15268       };
15269     }
15270   }
15271
15272   jresult = (void *)result;
15273   return jresult;
15274 }
15275
15276
15277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15278   void * jresult ;
15279   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15280   Dali::Property::Array::SizeType arg2 ;
15281   Dali::Property::Value *result = 0 ;
15282
15283   arg1 = (Dali::Property::Array *)jarg1;
15284   arg2 = (Dali::Property::Array::SizeType)jarg2;
15285   {
15286     try {
15287       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15288     } catch (std::out_of_range& e) {
15289       {
15290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15291       };
15292     } catch (std::exception& e) {
15293       {
15294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15295       };
15296     } catch (Dali::DaliException e) {
15297       {
15298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15299       };
15300     } catch (...) {
15301       {
15302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15303       };
15304     }
15305   }
15306
15307   jresult = (void *)result;
15308   return jresult;
15309 }
15310
15311
15312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15313   void * jresult ;
15314   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15315   Dali::Property::Array::SizeType arg2 ;
15316   Dali::Property::Value *result = 0 ;
15317
15318   arg1 = (Dali::Property::Array *)jarg1;
15319   arg2 = (Dali::Property::Array::SizeType)jarg2;
15320   {
15321     try {
15322       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15323     } catch (std::out_of_range& e) {
15324       {
15325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15326       };
15327     } catch (std::exception& e) {
15328       {
15329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15330       };
15331     } catch (Dali::DaliException e) {
15332       {
15333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15334       };
15335     } catch (...) {
15336       {
15337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15338       };
15339     }
15340   }
15341
15342   jresult = (void *)result;
15343   return jresult;
15344 }
15345
15346
15347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15348   void * jresult ;
15349   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15350   Dali::Property::Array *arg2 = 0 ;
15351   Dali::Property::Array *result = 0 ;
15352
15353   arg1 = (Dali::Property::Array *)jarg1;
15354   arg2 = (Dali::Property::Array *)jarg2;
15355   if (!arg2) {
15356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15357     return 0;
15358   }
15359   {
15360     try {
15361       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15362     } catch (std::out_of_range& e) {
15363       {
15364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15365       };
15366     } catch (std::exception& e) {
15367       {
15368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15369       };
15370     } catch (Dali::DaliException e) {
15371       {
15372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15373       };
15374     } catch (...) {
15375       {
15376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15377       };
15378     }
15379   }
15380
15381   jresult = (void *)result;
15382   return jresult;
15383 }
15384
15385
15386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15387   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15388   enum Dali::Property::Key::Type arg2 ;
15389
15390   arg1 = (Dali::Property::Key *)jarg1;
15391   arg2 = (enum Dali::Property::Key::Type)jarg2;
15392   if (arg1) (arg1)->type = arg2;
15393 }
15394
15395
15396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15397   int jresult ;
15398   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15399   enum Dali::Property::Key::Type result;
15400
15401   arg1 = (Dali::Property::Key *)jarg1;
15402   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15403   jresult = (int)result;
15404   return jresult;
15405 }
15406
15407
15408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15409   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15410   Dali::Property::Index arg2 ;
15411
15412   arg1 = (Dali::Property::Key *)jarg1;
15413   arg2 = (Dali::Property::Index)jarg2;
15414   if (arg1) (arg1)->indexKey = arg2;
15415 }
15416
15417
15418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15419   int jresult ;
15420   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15421   Dali::Property::Index result;
15422
15423   arg1 = (Dali::Property::Key *)jarg1;
15424   result = (Dali::Property::Index) ((arg1)->indexKey);
15425   jresult = result;
15426   return jresult;
15427 }
15428
15429
15430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15431   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15432   std::string *arg2 = 0 ;
15433
15434   arg1 = (Dali::Property::Key *)jarg1;
15435   if (!jarg2) {
15436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15437     return ;
15438   }
15439   std::string arg2_str(jarg2);
15440   arg2 = &arg2_str;
15441   if (arg1) (arg1)->stringKey = *arg2;
15442
15443   //argout typemap for const std::string&
15444
15445 }
15446
15447
15448 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15449   char * jresult ;
15450   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15451   std::string *result = 0 ;
15452
15453   arg1 = (Dali::Property::Key *)jarg1;
15454   result = (std::string *) & ((arg1)->stringKey);
15455   jresult = SWIG_csharp_string_callback(result->c_str());
15456   return jresult;
15457 }
15458
15459
15460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15461   void * jresult ;
15462   std::string *arg1 = 0 ;
15463   Dali::Property::Key *result = 0 ;
15464
15465   if (!jarg1) {
15466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15467     return 0;
15468   }
15469   std::string arg1_str(jarg1);
15470   arg1 = &arg1_str;
15471   {
15472     try {
15473       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15474     } catch (std::out_of_range& e) {
15475       {
15476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15477       };
15478     } catch (std::exception& e) {
15479       {
15480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15481       };
15482     } catch (Dali::DaliException e) {
15483       {
15484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15485       };
15486     } catch (...) {
15487       {
15488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15489       };
15490     }
15491   }
15492
15493   jresult = (void *)result;
15494
15495   //argout typemap for const std::string&
15496
15497   return jresult;
15498 }
15499
15500
15501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15502   void * jresult ;
15503   Dali::Property::Index arg1 ;
15504   Dali::Property::Key *result = 0 ;
15505
15506   arg1 = (Dali::Property::Index)jarg1;
15507   {
15508     try {
15509       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15510     } catch (std::out_of_range& e) {
15511       {
15512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15513       };
15514     } catch (std::exception& e) {
15515       {
15516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15517       };
15518     } catch (Dali::DaliException e) {
15519       {
15520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15521       };
15522     } catch (...) {
15523       {
15524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15525       };
15526     }
15527   }
15528
15529   jresult = (void *)result;
15530   return jresult;
15531 }
15532
15533
15534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15535   unsigned int jresult ;
15536   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15537   std::string *arg2 = 0 ;
15538   bool result;
15539
15540   arg1 = (Dali::Property::Key *)jarg1;
15541   if (!jarg2) {
15542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15543     return 0;
15544   }
15545   std::string arg2_str(jarg2);
15546   arg2 = &arg2_str;
15547   {
15548     try {
15549       result = (bool)(arg1)->operator ==((std::string const &)*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
15571   //argout typemap for const std::string&
15572
15573   return jresult;
15574 }
15575
15576
15577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15578   unsigned int jresult ;
15579   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15580   Dali::Property::Index arg2 ;
15581   bool result;
15582
15583   arg1 = (Dali::Property::Key *)jarg1;
15584   arg2 = (Dali::Property::Index)jarg2;
15585   {
15586     try {
15587       result = (bool)(arg1)->operator ==(arg2);
15588     } catch (std::out_of_range& e) {
15589       {
15590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15591       };
15592     } catch (std::exception& e) {
15593       {
15594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15595       };
15596     } catch (Dali::DaliException e) {
15597       {
15598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15599       };
15600     } catch (...) {
15601       {
15602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15603       };
15604     }
15605   }
15606
15607   jresult = result;
15608   return jresult;
15609 }
15610
15611
15612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15613   unsigned int jresult ;
15614   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15615   Dali::Property::Key *arg2 = 0 ;
15616   bool result;
15617
15618   arg1 = (Dali::Property::Key *)jarg1;
15619   arg2 = (Dali::Property::Key *)jarg2;
15620   if (!arg2) {
15621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15622     return 0;
15623   }
15624   {
15625     try {
15626       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15627     } catch (std::out_of_range& e) {
15628       {
15629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15630       };
15631     } catch (std::exception& e) {
15632       {
15633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15634       };
15635     } catch (Dali::DaliException e) {
15636       {
15637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15638       };
15639     } catch (...) {
15640       {
15641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15642       };
15643     }
15644   }
15645
15646   jresult = result;
15647   return jresult;
15648 }
15649
15650
15651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15652   unsigned int jresult ;
15653   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15654   std::string *arg2 = 0 ;
15655   bool result;
15656
15657   arg1 = (Dali::Property::Key *)jarg1;
15658   if (!jarg2) {
15659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15660     return 0;
15661   }
15662   std::string arg2_str(jarg2);
15663   arg2 = &arg2_str;
15664   {
15665     try {
15666       result = (bool)(arg1)->operator !=((std::string const &)*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
15688   //argout typemap for const std::string&
15689
15690   return jresult;
15691 }
15692
15693
15694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15695   unsigned int jresult ;
15696   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15697   Dali::Property::Index arg2 ;
15698   bool result;
15699
15700   arg1 = (Dali::Property::Key *)jarg1;
15701   arg2 = (Dali::Property::Index)jarg2;
15702   {
15703     try {
15704       result = (bool)(arg1)->operator !=(arg2);
15705     } catch (std::out_of_range& e) {
15706       {
15707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15708       };
15709     } catch (std::exception& e) {
15710       {
15711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15712       };
15713     } catch (Dali::DaliException e) {
15714       {
15715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15716       };
15717     } catch (...) {
15718       {
15719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15720       };
15721     }
15722   }
15723
15724   jresult = result;
15725   return jresult;
15726 }
15727
15728
15729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15730   unsigned int jresult ;
15731   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15732   Dali::Property::Key *arg2 = 0 ;
15733   bool result;
15734
15735   arg1 = (Dali::Property::Key *)jarg1;
15736   arg2 = (Dali::Property::Key *)jarg2;
15737   if (!arg2) {
15738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15739     return 0;
15740   }
15741   {
15742     try {
15743       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15744     } catch (std::out_of_range& e) {
15745       {
15746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15747       };
15748     } catch (std::exception& e) {
15749       {
15750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15751       };
15752     } catch (Dali::DaliException e) {
15753       {
15754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15755       };
15756     } catch (...) {
15757       {
15758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15759       };
15760     }
15761   }
15762
15763   jresult = result;
15764   return jresult;
15765 }
15766
15767
15768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15769   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15770
15771   arg1 = (Dali::Property::Key *)jarg1;
15772   {
15773     try {
15774       delete arg1;
15775     } catch (std::out_of_range& e) {
15776       {
15777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15778       };
15779     } catch (std::exception& e) {
15780       {
15781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15782       };
15783     } catch (Dali::DaliException e) {
15784       {
15785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15786       };
15787     } catch (...) {
15788       {
15789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15790       };
15791     }
15792   }
15793
15794 }
15795
15796
15797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15798   void * jresult ;
15799   Dali::Property::Map *result = 0 ;
15800
15801   {
15802     try {
15803       result = (Dali::Property::Map *)new Dali::Property::Map();
15804     } catch (std::out_of_range& e) {
15805       {
15806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15807       };
15808     } catch (std::exception& e) {
15809       {
15810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15811       };
15812     } catch (Dali::DaliException e) {
15813       {
15814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15815       };
15816     } catch (...) {
15817       {
15818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15819       };
15820     }
15821   }
15822
15823   jresult = (void *)result;
15824   return jresult;
15825 }
15826
15827
15828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15829   void * jresult ;
15830   Dali::Property::Map *arg1 = 0 ;
15831   Dali::Property::Map *result = 0 ;
15832
15833   arg1 = (Dali::Property::Map *)jarg1;
15834   if (!arg1) {
15835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15836     return 0;
15837   }
15838   {
15839     try {
15840       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15841     } catch (std::out_of_range& e) {
15842       {
15843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15844       };
15845     } catch (std::exception& e) {
15846       {
15847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15848       };
15849     } catch (Dali::DaliException e) {
15850       {
15851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15852       };
15853     } catch (...) {
15854       {
15855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15856       };
15857     }
15858   }
15859
15860   jresult = (void *)result;
15861   return jresult;
15862 }
15863
15864
15865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15866   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15867
15868   arg1 = (Dali::Property::Map *)jarg1;
15869   {
15870     try {
15871       delete arg1;
15872     } catch (std::out_of_range& e) {
15873       {
15874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15875       };
15876     } catch (std::exception& e) {
15877       {
15878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15879       };
15880     } catch (Dali::DaliException e) {
15881       {
15882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15883       };
15884     } catch (...) {
15885       {
15886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15887       };
15888     }
15889   }
15890
15891 }
15892
15893
15894 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15895   unsigned long jresult ;
15896   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15897   Dali::Property::Map::SizeType result;
15898
15899   arg1 = (Dali::Property::Map *)jarg1;
15900   {
15901     try {
15902       result = ((Dali::Property::Map const *)arg1)->Count();
15903     } catch (std::out_of_range& e) {
15904       {
15905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15906       };
15907     } catch (std::exception& e) {
15908       {
15909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15910       };
15911     } catch (Dali::DaliException e) {
15912       {
15913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15914       };
15915     } catch (...) {
15916       {
15917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15918       };
15919     }
15920   }
15921
15922   jresult = (unsigned long)result;
15923   return jresult;
15924 }
15925
15926
15927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15928   unsigned int jresult ;
15929   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15930   bool result;
15931
15932   arg1 = (Dali::Property::Map *)jarg1;
15933   {
15934     try {
15935       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15936     } catch (std::out_of_range& e) {
15937       {
15938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15939       };
15940     } catch (std::exception& e) {
15941       {
15942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15943       };
15944     } catch (Dali::DaliException e) {
15945       {
15946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15947       };
15948     } catch (...) {
15949       {
15950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15951       };
15952     }
15953   }
15954
15955   jresult = result;
15956   return jresult;
15957 }
15958
15959
15960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15961   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15962   char *arg2 = (char *) 0 ;
15963   Dali::Property::Value *arg3 = 0 ;
15964
15965   arg1 = (Dali::Property::Map *)jarg1;
15966   arg2 = (char *)jarg2;
15967   arg3 = (Dali::Property::Value *)jarg3;
15968   if (!arg3) {
15969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15970     return ;
15971   }
15972   {
15973     try {
15974       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15975     } catch (std::out_of_range& e) {
15976       {
15977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15978       };
15979     } catch (std::exception& e) {
15980       {
15981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15982       };
15983     } catch (Dali::DaliException e) {
15984       {
15985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15986       };
15987     } catch (...) {
15988       {
15989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15990       };
15991     }
15992   }
15993
15994 }
15995
15996
15997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15998   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15999   Dali::Property::Index arg2 ;
16000   Dali::Property::Value *arg3 = 0 ;
16001
16002   arg1 = (Dali::Property::Map *)jarg1;
16003   arg2 = (Dali::Property::Index)jarg2;
16004   arg3 = (Dali::Property::Value *)jarg3;
16005   if (!arg3) {
16006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16007     return ;
16008   }
16009   {
16010     try {
16011       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16012     } catch (std::out_of_range& e) {
16013       {
16014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16015       };
16016     } catch (std::exception& e) {
16017       {
16018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16019       };
16020     } catch (Dali::DaliException e) {
16021       {
16022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16023       };
16024     } catch (...) {
16025       {
16026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16027       };
16028     }
16029   }
16030
16031 }
16032
16033
16034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16035   void * jresult ;
16036   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16037   char *arg2 = (char *) 0 ;
16038   Dali::Property::Value *arg3 = 0 ;
16039   Dali::Property::Map *result = 0 ;
16040
16041   arg1 = (Dali::Property::Map *)jarg1;
16042   arg2 = (char *)jarg2;
16043   arg3 = (Dali::Property::Value *)jarg3;
16044   if (!arg3) {
16045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16046     return 0;
16047   }
16048   {
16049     try {
16050       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16051     } catch (std::out_of_range& e) {
16052       {
16053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16054       };
16055     } catch (std::exception& e) {
16056       {
16057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16058       };
16059     } catch (Dali::DaliException e) {
16060       {
16061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16062       };
16063     } catch (...) {
16064       {
16065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16066       };
16067     }
16068   }
16069
16070   jresult = (void *)result;
16071   return jresult;
16072 }
16073
16074
16075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16076   void * jresult ;
16077   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16078   Dali::Property::Index arg2 ;
16079   Dali::Property::Value *arg3 = 0 ;
16080   Dali::Property::Map *result = 0 ;
16081
16082   arg1 = (Dali::Property::Map *)jarg1;
16083   arg2 = (Dali::Property::Index)jarg2;
16084   arg3 = (Dali::Property::Value *)jarg3;
16085   if (!arg3) {
16086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16087     return 0;
16088   }
16089   {
16090     try {
16091       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16092     } catch (std::out_of_range& e) {
16093       {
16094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16095       };
16096     } catch (std::exception& e) {
16097       {
16098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16099       };
16100     } catch (Dali::DaliException e) {
16101       {
16102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16103       };
16104     } catch (...) {
16105       {
16106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16107       };
16108     }
16109   }
16110
16111   jresult = (void *)result;
16112   return jresult;
16113 }
16114
16115
16116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16117   void * jresult ;
16118   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16119   Dali::Property::Map::SizeType arg2 ;
16120   Dali::Property::Value *result = 0 ;
16121
16122   arg1 = (Dali::Property::Map *)jarg1;
16123   arg2 = (Dali::Property::Map::SizeType)jarg2;
16124   {
16125     try {
16126       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16127     } catch (std::out_of_range& e) {
16128       {
16129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16130       };
16131     } catch (std::exception& e) {
16132       {
16133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16134       };
16135     } catch (Dali::DaliException e) {
16136       {
16137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16138       };
16139     } catch (...) {
16140       {
16141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16142       };
16143     }
16144   }
16145
16146   jresult = (void *)result;
16147   return jresult;
16148 }
16149
16150
16151 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16152   char * jresult ;
16153   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16154   Dali::Property::Map::SizeType arg2 ;
16155   std::string *result = 0 ;
16156
16157   arg1 = (Dali::Property::Map *)jarg1;
16158   arg2 = (Dali::Property::Map::SizeType)jarg2;
16159   {
16160     try {
16161       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16162     } catch (std::out_of_range& e) {
16163       {
16164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16165       };
16166     } catch (std::exception& e) {
16167       {
16168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16169       };
16170     } catch (Dali::DaliException e) {
16171       {
16172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16173       };
16174     } catch (...) {
16175       {
16176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16177       };
16178     }
16179   }
16180
16181   jresult = SWIG_csharp_string_callback(result->c_str());
16182   return jresult;
16183 }
16184
16185
16186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16187   void * jresult ;
16188   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16189   Dali::Property::Map::SizeType arg2 ;
16190   SwigValueWrapper< Dali::Property::Key > result;
16191
16192   arg1 = (Dali::Property::Map *)jarg1;
16193   arg2 = (Dali::Property::Map::SizeType)jarg2;
16194   {
16195     try {
16196       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16197     } catch (std::out_of_range& e) {
16198       {
16199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16200       };
16201     } catch (std::exception& e) {
16202       {
16203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16204       };
16205     } catch (Dali::DaliException e) {
16206       {
16207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16208       };
16209     } catch (...) {
16210       {
16211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16212       };
16213     }
16214   }
16215
16216   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16217   return jresult;
16218 }
16219
16220
16221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16222   void * jresult ;
16223   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16224   Dali::Property::Map::SizeType arg2 ;
16225   StringValuePair *result = 0 ;
16226
16227   arg1 = (Dali::Property::Map *)jarg1;
16228   arg2 = (Dali::Property::Map::SizeType)jarg2;
16229   {
16230     try {
16231       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16232     } catch (std::out_of_range& e) {
16233       {
16234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16235       };
16236     } catch (std::exception& e) {
16237       {
16238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16239       };
16240     } catch (Dali::DaliException e) {
16241       {
16242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16243       };
16244     } catch (...) {
16245       {
16246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16247       };
16248     }
16249   }
16250
16251   jresult = (void *)result;
16252   return jresult;
16253 }
16254
16255
16256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16257   void * jresult ;
16258   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16259   char *arg2 = (char *) 0 ;
16260   Dali::Property::Value *result = 0 ;
16261
16262   arg1 = (Dali::Property::Map *)jarg1;
16263   arg2 = (char *)jarg2;
16264   {
16265     try {
16266       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16267     } catch (std::out_of_range& e) {
16268       {
16269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16270       };
16271     } catch (std::exception& e) {
16272       {
16273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16274       };
16275     } catch (Dali::DaliException e) {
16276       {
16277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16278       };
16279     } catch (...) {
16280       {
16281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16282       };
16283     }
16284   }
16285
16286   jresult = (void *)result;
16287   return jresult;
16288 }
16289
16290
16291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16292   void * jresult ;
16293   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16294   Dali::Property::Index arg2 ;
16295   Dali::Property::Value *result = 0 ;
16296
16297   arg1 = (Dali::Property::Map *)jarg1;
16298   arg2 = (Dali::Property::Index)jarg2;
16299   {
16300     try {
16301       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16302     } catch (std::out_of_range& e) {
16303       {
16304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16305       };
16306     } catch (std::exception& e) {
16307       {
16308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16309       };
16310     } catch (Dali::DaliException e) {
16311       {
16312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16313       };
16314     } catch (...) {
16315       {
16316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16317       };
16318     }
16319   }
16320
16321   jresult = (void *)result;
16322   return jresult;
16323 }
16324
16325
16326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16327   void * jresult ;
16328   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16329   Dali::Property::Index arg2 ;
16330   std::string *arg3 = 0 ;
16331   Dali::Property::Value *result = 0 ;
16332
16333   arg1 = (Dali::Property::Map *)jarg1;
16334   arg2 = (Dali::Property::Index)jarg2;
16335   if (!jarg3) {
16336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16337     return 0;
16338   }
16339   std::string arg3_str(jarg3);
16340   arg3 = &arg3_str;
16341   {
16342     try {
16343       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16344     } catch (std::out_of_range& e) {
16345       {
16346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16347       };
16348     } catch (std::exception& e) {
16349       {
16350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16351       };
16352     } catch (Dali::DaliException e) {
16353       {
16354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16355       };
16356     } catch (...) {
16357       {
16358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16359       };
16360     }
16361   }
16362
16363   jresult = (void *)result;
16364
16365   //argout typemap for const std::string&
16366
16367   return jresult;
16368 }
16369
16370
16371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16372   void * jresult ;
16373   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16374   std::string *arg2 = 0 ;
16375   Dali::Property::Type arg3 ;
16376   Dali::Property::Value *result = 0 ;
16377
16378   arg1 = (Dali::Property::Map *)jarg1;
16379   if (!jarg2) {
16380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16381     return 0;
16382   }
16383   std::string arg2_str(jarg2);
16384   arg2 = &arg2_str;
16385   arg3 = (Dali::Property::Type)jarg3;
16386   {
16387     try {
16388       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16389     } catch (std::out_of_range& e) {
16390       {
16391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16392       };
16393     } catch (std::exception& e) {
16394       {
16395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16396       };
16397     } catch (Dali::DaliException e) {
16398       {
16399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16400       };
16401     } catch (...) {
16402       {
16403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16404       };
16405     }
16406   }
16407
16408   jresult = (void *)result;
16409
16410   //argout typemap for const std::string&
16411
16412   return jresult;
16413 }
16414
16415
16416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16417   void * jresult ;
16418   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16419   Dali::Property::Index arg2 ;
16420   Dali::Property::Type arg3 ;
16421   Dali::Property::Value *result = 0 ;
16422
16423   arg1 = (Dali::Property::Map *)jarg1;
16424   arg2 = (Dali::Property::Index)jarg2;
16425   arg3 = (Dali::Property::Type)jarg3;
16426   {
16427     try {
16428       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16429     } catch (std::out_of_range& e) {
16430       {
16431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16432       };
16433     } catch (std::exception& e) {
16434       {
16435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16436       };
16437     } catch (Dali::DaliException e) {
16438       {
16439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16440       };
16441     } catch (...) {
16442       {
16443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16444       };
16445     }
16446   }
16447
16448   jresult = (void *)result;
16449   return jresult;
16450 }
16451
16452
16453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16454   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16455
16456   arg1 = (Dali::Property::Map *)jarg1;
16457   {
16458     try {
16459       (arg1)->Clear();
16460     } catch (std::out_of_range& e) {
16461       {
16462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16463       };
16464     } catch (std::exception& e) {
16465       {
16466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16467       };
16468     } catch (Dali::DaliException e) {
16469       {
16470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16471       };
16472     } catch (...) {
16473       {
16474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16475       };
16476     }
16477   }
16478
16479 }
16480
16481
16482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16483   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16484   Dali::Property::Map *arg2 = 0 ;
16485
16486   arg1 = (Dali::Property::Map *)jarg1;
16487   arg2 = (Dali::Property::Map *)jarg2;
16488   if (!arg2) {
16489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16490     return ;
16491   }
16492   {
16493     try {
16494       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16495     } catch (std::out_of_range& e) {
16496       {
16497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16498       };
16499     } catch (std::exception& e) {
16500       {
16501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16502       };
16503     } catch (Dali::DaliException e) {
16504       {
16505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16506       };
16507     } catch (...) {
16508       {
16509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16510       };
16511     }
16512   }
16513
16514 }
16515
16516
16517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16518   void * jresult ;
16519   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16520   std::string *arg2 = 0 ;
16521   Dali::Property::Value *result = 0 ;
16522
16523   arg1 = (Dali::Property::Map *)jarg1;
16524   if (!jarg2) {
16525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16526     return 0;
16527   }
16528   std::string arg2_str(jarg2);
16529   arg2 = &arg2_str;
16530   {
16531     try {
16532       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*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
16554   //argout typemap for const std::string&
16555
16556   return jresult;
16557 }
16558
16559
16560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16561   void * jresult ;
16562   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16563   Dali::Property::Index arg2 ;
16564   Dali::Property::Value *result = 0 ;
16565
16566   arg1 = (Dali::Property::Map *)jarg1;
16567   arg2 = (Dali::Property::Index)jarg2;
16568   {
16569     try {
16570       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16571     } catch (std::out_of_range& e) {
16572       {
16573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16574       };
16575     } catch (std::exception& e) {
16576       {
16577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16578       };
16579     } catch (Dali::DaliException e) {
16580       {
16581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16582       };
16583     } catch (...) {
16584       {
16585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16586       };
16587     }
16588   }
16589
16590   jresult = (void *)result;
16591   return jresult;
16592 }
16593
16594
16595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16596   void * jresult ;
16597   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16598   Dali::Property::Map *arg2 = 0 ;
16599   Dali::Property::Map *result = 0 ;
16600
16601   arg1 = (Dali::Property::Map *)jarg1;
16602   arg2 = (Dali::Property::Map *)jarg2;
16603   if (!arg2) {
16604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16605     return 0;
16606   }
16607   {
16608     try {
16609       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16610     } catch (std::out_of_range& e) {
16611       {
16612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16613       };
16614     } catch (std::exception& e) {
16615       {
16616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16617       };
16618     } catch (Dali::DaliException e) {
16619       {
16620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16621       };
16622     } catch (...) {
16623       {
16624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16625       };
16626     }
16627   }
16628
16629   jresult = (void *)result;
16630   return jresult;
16631 }
16632
16633
16634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16635
16636   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16637
16638   if (!jarg2) {
16639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16640     return;
16641   }
16642   std::string arg2_str(jarg2);
16643   std::string* arg2 = &arg2_str;
16644
16645   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16646
16647   {
16648     try {
16649       arg1->operator[]((std::string const &)*arg2) = *arg3;
16650     } catch (std::out_of_range& e) {
16651       {
16652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16653       };
16654     } catch (std::exception& e) {
16655       {
16656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16657       };
16658     } catch (Dali::DaliException e) {
16659       {
16660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16661       };
16662     } catch (...) {
16663       {
16664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16665       };
16666     }
16667   }
16668 }
16669
16670
16671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16672
16673   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16674   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16675   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16676
16677   {
16678     try {
16679       arg1->operator[](arg2) = *arg3;
16680     } catch (std::out_of_range& e) {
16681       {
16682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16683       };
16684     } catch (std::exception& e) {
16685       {
16686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16687       };
16688     } catch (Dali::DaliException e) {
16689       {
16690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16691       };
16692     } catch (...) {
16693       {
16694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16695       };
16696     }
16697   }
16698 }
16699
16700
16701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16702   void * jresult ;
16703   Dali::Property::Value *result = 0 ;
16704
16705   {
16706     try {
16707       result = (Dali::Property::Value *)new Dali::Property::Value();
16708     } catch (std::out_of_range& e) {
16709       {
16710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16711       };
16712     } catch (std::exception& e) {
16713       {
16714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16715       };
16716     } catch (Dali::DaliException e) {
16717       {
16718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16719       };
16720     } catch (...) {
16721       {
16722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16723       };
16724     }
16725   }
16726
16727   jresult = (void *)result;
16728   return jresult;
16729 }
16730
16731
16732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16733   void * jresult ;
16734   bool arg1 ;
16735   Dali::Property::Value *result = 0 ;
16736
16737   arg1 = jarg1 ? true : false;
16738   {
16739     try {
16740       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16741     } catch (std::out_of_range& e) {
16742       {
16743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16744       };
16745     } catch (std::exception& e) {
16746       {
16747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16748       };
16749     } catch (Dali::DaliException e) {
16750       {
16751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16752       };
16753     } catch (...) {
16754       {
16755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16756       };
16757     }
16758   }
16759
16760   jresult = (void *)result;
16761   return jresult;
16762 }
16763
16764
16765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16766   void * jresult ;
16767   int arg1 ;
16768   Dali::Property::Value *result = 0 ;
16769
16770   arg1 = (int)jarg1;
16771   {
16772     try {
16773       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16774     } catch (std::out_of_range& e) {
16775       {
16776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16777       };
16778     } catch (std::exception& e) {
16779       {
16780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16781       };
16782     } catch (Dali::DaliException e) {
16783       {
16784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16785       };
16786     } catch (...) {
16787       {
16788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16789       };
16790     }
16791   }
16792
16793   jresult = (void *)result;
16794   return jresult;
16795 }
16796
16797
16798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16799   void * jresult ;
16800   float arg1 ;
16801   Dali::Property::Value *result = 0 ;
16802
16803   arg1 = (float)jarg1;
16804   {
16805     try {
16806       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16807     } catch (std::out_of_range& e) {
16808       {
16809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16810       };
16811     } catch (std::exception& e) {
16812       {
16813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16814       };
16815     } catch (Dali::DaliException e) {
16816       {
16817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16818       };
16819     } catch (...) {
16820       {
16821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16822       };
16823     }
16824   }
16825
16826   jresult = (void *)result;
16827   return jresult;
16828 }
16829
16830
16831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16832   void * jresult ;
16833   Dali::Vector2 *arg1 = 0 ;
16834   Dali::Property::Value *result = 0 ;
16835
16836   arg1 = (Dali::Vector2 *)jarg1;
16837   if (!arg1) {
16838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16839     return 0;
16840   }
16841   {
16842     try {
16843       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16844     } catch (std::out_of_range& e) {
16845       {
16846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16847       };
16848     } catch (std::exception& e) {
16849       {
16850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16851       };
16852     } catch (Dali::DaliException e) {
16853       {
16854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16855       };
16856     } catch (...) {
16857       {
16858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16859       };
16860     }
16861   }
16862
16863   jresult = (void *)result;
16864   return jresult;
16865 }
16866
16867
16868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16869   void * jresult ;
16870   Dali::Vector3 *arg1 = 0 ;
16871   Dali::Property::Value *result = 0 ;
16872
16873   arg1 = (Dali::Vector3 *)jarg1;
16874   if (!arg1) {
16875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16876     return 0;
16877   }
16878   {
16879     try {
16880       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16881     } catch (std::out_of_range& e) {
16882       {
16883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16884       };
16885     } catch (std::exception& e) {
16886       {
16887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16888       };
16889     } catch (Dali::DaliException e) {
16890       {
16891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16892       };
16893     } catch (...) {
16894       {
16895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16896       };
16897     }
16898   }
16899
16900   jresult = (void *)result;
16901   return jresult;
16902 }
16903
16904
16905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16906   void * jresult ;
16907   Dali::Vector4 *arg1 = 0 ;
16908   Dali::Property::Value *result = 0 ;
16909
16910   arg1 = (Dali::Vector4 *)jarg1;
16911   if (!arg1) {
16912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16913     return 0;
16914   }
16915   {
16916     try {
16917       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16918     } catch (std::out_of_range& e) {
16919       {
16920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16921       };
16922     } catch (std::exception& e) {
16923       {
16924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16925       };
16926     } catch (Dali::DaliException e) {
16927       {
16928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16929       };
16930     } catch (...) {
16931       {
16932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16933       };
16934     }
16935   }
16936
16937   jresult = (void *)result;
16938   return jresult;
16939 }
16940
16941
16942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16943   void * jresult ;
16944   Dali::Matrix3 *arg1 = 0 ;
16945   Dali::Property::Value *result = 0 ;
16946
16947   arg1 = (Dali::Matrix3 *)jarg1;
16948   if (!arg1) {
16949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16950     return 0;
16951   }
16952   {
16953     try {
16954       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16955     } catch (std::out_of_range& e) {
16956       {
16957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16958       };
16959     } catch (std::exception& e) {
16960       {
16961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16962       };
16963     } catch (Dali::DaliException e) {
16964       {
16965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16966       };
16967     } catch (...) {
16968       {
16969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16970       };
16971     }
16972   }
16973
16974   jresult = (void *)result;
16975   return jresult;
16976 }
16977
16978
16979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16980   void * jresult ;
16981   Dali::Matrix *arg1 = 0 ;
16982   Dali::Property::Value *result = 0 ;
16983
16984   arg1 = (Dali::Matrix *)jarg1;
16985   if (!arg1) {
16986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16987     return 0;
16988   }
16989   {
16990     try {
16991       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16992     } catch (std::out_of_range& e) {
16993       {
16994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16995       };
16996     } catch (std::exception& e) {
16997       {
16998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16999       };
17000     } catch (Dali::DaliException e) {
17001       {
17002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17003       };
17004     } catch (...) {
17005       {
17006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17007       };
17008     }
17009   }
17010
17011   jresult = (void *)result;
17012   return jresult;
17013 }
17014
17015
17016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
17017   void * jresult ;
17018   Dali::Rect< int > *arg1 = 0 ;
17019   Dali::Property::Value *result = 0 ;
17020
17021   arg1 = (Dali::Rect< int > *)jarg1;
17022   if (!arg1) {
17023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17024     return 0;
17025   }
17026   {
17027     try {
17028       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17029     } catch (std::out_of_range& e) {
17030       {
17031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17032       };
17033     } catch (std::exception& e) {
17034       {
17035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17036       };
17037     } catch (Dali::DaliException e) {
17038       {
17039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17040       };
17041     } catch (...) {
17042       {
17043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17044       };
17045     }
17046   }
17047
17048   jresult = (void *)result;
17049   return jresult;
17050 }
17051
17052
17053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17054   void * jresult ;
17055   Dali::AngleAxis *arg1 = 0 ;
17056   Dali::Property::Value *result = 0 ;
17057
17058   arg1 = (Dali::AngleAxis *)jarg1;
17059   if (!arg1) {
17060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17061     return 0;
17062   }
17063   {
17064     try {
17065       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17066     } catch (std::out_of_range& e) {
17067       {
17068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17069       };
17070     } catch (std::exception& e) {
17071       {
17072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17073       };
17074     } catch (Dali::DaliException e) {
17075       {
17076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17077       };
17078     } catch (...) {
17079       {
17080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17081       };
17082     }
17083   }
17084
17085   jresult = (void *)result;
17086   return jresult;
17087 }
17088
17089
17090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17091   void * jresult ;
17092   Dali::Quaternion *arg1 = 0 ;
17093   Dali::Property::Value *result = 0 ;
17094
17095   arg1 = (Dali::Quaternion *)jarg1;
17096   if (!arg1) {
17097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17098     return 0;
17099   }
17100   {
17101     try {
17102       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion 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   return jresult;
17124 }
17125
17126
17127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17128   void * jresult ;
17129   std::string *arg1 = 0 ;
17130   Dali::Property::Value *result = 0 ;
17131
17132   if (!jarg1) {
17133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17134     return 0;
17135   }
17136   std::string arg1_str(jarg1);
17137   arg1 = &arg1_str;
17138   {
17139     try {
17140       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17141     } catch (std::out_of_range& e) {
17142       {
17143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17144       };
17145     } catch (std::exception& e) {
17146       {
17147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17148       };
17149     } catch (Dali::DaliException e) {
17150       {
17151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17152       };
17153     } catch (...) {
17154       {
17155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17156       };
17157     }
17158   }
17159
17160   jresult = (void *)result;
17161
17162   //argout typemap for const std::string&
17163
17164   return jresult;
17165 }
17166
17167
17168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17169   void * jresult ;
17170   Dali::Property::Array *arg1 = 0 ;
17171   Dali::Property::Value *result = 0 ;
17172
17173   arg1 = (Dali::Property::Array *)jarg1;
17174   if (!arg1) {
17175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17176     return 0;
17177   }
17178   {
17179     try {
17180       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17181     } catch (std::out_of_range& e) {
17182       {
17183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17184       };
17185     } catch (std::exception& e) {
17186       {
17187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17188       };
17189     } catch (Dali::DaliException e) {
17190       {
17191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17192       };
17193     } catch (...) {
17194       {
17195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17196       };
17197     }
17198   }
17199
17200   jresult = (void *)result;
17201   return jresult;
17202 }
17203
17204
17205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17206   void * jresult ;
17207   Dali::Property::Map *arg1 = 0 ;
17208   Dali::Property::Value *result = 0 ;
17209
17210   arg1 = (Dali::Property::Map *)jarg1;
17211   if (!arg1) {
17212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17213     return 0;
17214   }
17215   {
17216     try {
17217       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17218     } catch (std::out_of_range& e) {
17219       {
17220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17221       };
17222     } catch (std::exception& e) {
17223       {
17224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17225       };
17226     } catch (Dali::DaliException e) {
17227       {
17228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17229       };
17230     } catch (...) {
17231       {
17232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17233       };
17234     }
17235   }
17236
17237   jresult = (void *)result;
17238   return jresult;
17239 }
17240
17241
17242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17243   void * jresult ;
17244   Extents *arg1 = 0 ;
17245   Dali::Property::Value *result = 0 ;
17246
17247   arg1 = (Extents *)jarg1;
17248   if (!arg1) {
17249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17250     return 0;
17251   }
17252   {
17253     try {
17254       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17255     } catch (std::out_of_range& e) {
17256       {
17257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17258       };
17259     } catch (std::exception& e) {
17260       {
17261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17262       };
17263     } catch (...) {
17264       {
17265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17266       };
17267     }
17268   }
17269   jresult = (void *)result;
17270   return jresult;
17271 }
17272
17273
17274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17275   void * jresult ;
17276   Dali::Property::Type arg1 ;
17277   Dali::Property::Value *result = 0 ;
17278
17279   arg1 = (Dali::Property::Type)jarg1;
17280   {
17281     try {
17282       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17283     } catch (std::out_of_range& e) {
17284       {
17285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17286       };
17287     } catch (std::exception& e) {
17288       {
17289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17290       };
17291     } catch (Dali::DaliException e) {
17292       {
17293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17294       };
17295     } catch (...) {
17296       {
17297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17298       };
17299     }
17300   }
17301
17302   jresult = (void *)result;
17303   return jresult;
17304 }
17305
17306
17307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17308   void * jresult ;
17309   Dali::Property::Value *arg1 = 0 ;
17310   Dali::Property::Value *result = 0 ;
17311
17312   arg1 = (Dali::Property::Value *)jarg1;
17313   if (!arg1) {
17314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17315     return 0;
17316   }
17317   {
17318     try {
17319       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17320     } catch (std::out_of_range& e) {
17321       {
17322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17323       };
17324     } catch (std::exception& e) {
17325       {
17326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17327       };
17328     } catch (Dali::DaliException e) {
17329       {
17330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17331       };
17332     } catch (...) {
17333       {
17334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17335       };
17336     }
17337   }
17338
17339   jresult = (void *)result;
17340   return jresult;
17341 }
17342
17343
17344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17345   void * jresult ;
17346   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17347   Dali::Property::Value *arg2 = 0 ;
17348   Dali::Property::Value *result = 0 ;
17349
17350   arg1 = (Dali::Property::Value *)jarg1;
17351   arg2 = (Dali::Property::Value *)jarg2;
17352   if (!arg2) {
17353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17354     return 0;
17355   }
17356   {
17357     try {
17358       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17359     } catch (std::out_of_range& e) {
17360       {
17361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17362       };
17363     } catch (std::exception& e) {
17364       {
17365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17366       };
17367     } catch (Dali::DaliException e) {
17368       {
17369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17370       };
17371     } catch (...) {
17372       {
17373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17374       };
17375     }
17376   }
17377
17378   jresult = (void *)result;
17379   return jresult;
17380 }
17381
17382
17383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17384   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17385
17386   arg1 = (Dali::Property::Value *)jarg1;
17387   {
17388     try {
17389       delete arg1;
17390     } catch (std::out_of_range& e) {
17391       {
17392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17393       };
17394     } catch (std::exception& e) {
17395       {
17396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17397       };
17398     } catch (Dali::DaliException e) {
17399       {
17400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17401       };
17402     } catch (...) {
17403       {
17404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17405       };
17406     }
17407   }
17408
17409 }
17410
17411
17412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17413   int jresult ;
17414   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17415   Dali::Property::Type result;
17416
17417   arg1 = (Dali::Property::Value *)jarg1;
17418   {
17419     try {
17420       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17421     } catch (std::out_of_range& e) {
17422       {
17423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17424       };
17425     } catch (std::exception& e) {
17426       {
17427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17428       };
17429     } catch (Dali::DaliException e) {
17430       {
17431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17432       };
17433     } catch (...) {
17434       {
17435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17436       };
17437     }
17438   }
17439
17440   jresult = (int)result;
17441   return jresult;
17442 }
17443
17444
17445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17446   unsigned int jresult ;
17447   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17448   bool *arg2 = 0 ;
17449   bool result;
17450
17451   arg1 = (Dali::Property::Value *)jarg1;
17452   arg2 = (bool *)jarg2;
17453   {
17454     try {
17455       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17456     } catch (std::out_of_range& e) {
17457       {
17458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17459       };
17460     } catch (std::exception& e) {
17461       {
17462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17463       };
17464     } catch (Dali::DaliException e) {
17465       {
17466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17467       };
17468     } catch (...) {
17469       {
17470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17471       };
17472     }
17473   }
17474
17475   jresult = result;
17476   return jresult;
17477 }
17478
17479
17480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17481   unsigned int jresult ;
17482   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17483   float *arg2 = 0 ;
17484   bool result;
17485
17486   arg1 = (Dali::Property::Value *)jarg1;
17487   arg2 = (float *)jarg2;
17488   {
17489     try {
17490       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17491     } catch (std::out_of_range& e) {
17492       {
17493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17494       };
17495     } catch (std::exception& e) {
17496       {
17497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17498       };
17499     } catch (Dali::DaliException e) {
17500       {
17501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17502       };
17503     } catch (...) {
17504       {
17505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17506       };
17507     }
17508   }
17509
17510   jresult = result;
17511   return jresult;
17512 }
17513
17514
17515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17516   unsigned int jresult ;
17517   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17518   int *arg2 = 0 ;
17519   bool result;
17520
17521   arg1 = (Dali::Property::Value *)jarg1;
17522   arg2 = (int *)jarg2;
17523   {
17524     try {
17525       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17526     } catch (std::out_of_range& e) {
17527       {
17528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17529       };
17530     } catch (std::exception& e) {
17531       {
17532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17533       };
17534     } catch (Dali::DaliException e) {
17535       {
17536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17537       };
17538     } catch (...) {
17539       {
17540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17541       };
17542     }
17543   }
17544
17545   jresult = result;
17546   return jresult;
17547 }
17548
17549
17550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17551   unsigned int jresult ;
17552   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17553   Dali::Rect< int > *arg2 = 0 ;
17554   bool result;
17555
17556   arg1 = (Dali::Property::Value *)jarg1;
17557   arg2 = (Dali::Rect< int > *)jarg2;
17558   if (!arg2) {
17559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17560     return 0;
17561   }
17562   {
17563     try {
17564       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17565     } catch (std::out_of_range& e) {
17566       {
17567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17568       };
17569     } catch (std::exception& e) {
17570       {
17571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17572       };
17573     } catch (Dali::DaliException e) {
17574       {
17575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17576       };
17577     } catch (...) {
17578       {
17579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17580       };
17581     }
17582   }
17583
17584   jresult = result;
17585   return jresult;
17586 }
17587
17588
17589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17590   unsigned int jresult ;
17591   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17592   Dali::Vector2 *arg2 = 0 ;
17593   bool result;
17594
17595   arg1 = (Dali::Property::Value *)jarg1;
17596   arg2 = (Dali::Vector2 *)jarg2;
17597   if (!arg2) {
17598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17599     return 0;
17600   }
17601   {
17602     try {
17603       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17604     } catch (std::out_of_range& e) {
17605       {
17606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17607       };
17608     } catch (std::exception& e) {
17609       {
17610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17611       };
17612     } catch (Dali::DaliException e) {
17613       {
17614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17615       };
17616     } catch (...) {
17617       {
17618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17619       };
17620     }
17621   }
17622
17623   jresult = result;
17624   return jresult;
17625 }
17626
17627
17628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17629   unsigned int jresult ;
17630   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17631   Dali::Vector3 *arg2 = 0 ;
17632   bool result;
17633
17634   arg1 = (Dali::Property::Value *)jarg1;
17635   arg2 = (Dali::Vector3 *)jarg2;
17636   if (!arg2) {
17637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17638     return 0;
17639   }
17640   {
17641     try {
17642       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17643     } catch (std::out_of_range& e) {
17644       {
17645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17646       };
17647     } catch (std::exception& e) {
17648       {
17649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17650       };
17651     } catch (Dali::DaliException e) {
17652       {
17653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17654       };
17655     } catch (...) {
17656       {
17657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17658       };
17659     }
17660   }
17661
17662   jresult = result;
17663   return jresult;
17664 }
17665
17666
17667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17668   unsigned int jresult ;
17669   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17670   Dali::Vector4 *arg2 = 0 ;
17671   bool result;
17672
17673   arg1 = (Dali::Property::Value *)jarg1;
17674   arg2 = (Dali::Vector4 *)jarg2;
17675   if (!arg2) {
17676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17677     return 0;
17678   }
17679   {
17680     try {
17681       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17682     } catch (std::out_of_range& e) {
17683       {
17684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17685       };
17686     } catch (std::exception& e) {
17687       {
17688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17689       };
17690     } catch (Dali::DaliException e) {
17691       {
17692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17693       };
17694     } catch (...) {
17695       {
17696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17697       };
17698     }
17699   }
17700
17701   jresult = result;
17702   return jresult;
17703 }
17704
17705
17706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17707   unsigned int jresult ;
17708   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17709   Dali::Matrix3 *arg2 = 0 ;
17710   bool result;
17711
17712   arg1 = (Dali::Property::Value *)jarg1;
17713   arg2 = (Dali::Matrix3 *)jarg2;
17714   if (!arg2) {
17715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17716     return 0;
17717   }
17718   {
17719     try {
17720       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17721     } catch (std::out_of_range& e) {
17722       {
17723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17724       };
17725     } catch (std::exception& e) {
17726       {
17727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17728       };
17729     } catch (Dali::DaliException e) {
17730       {
17731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17732       };
17733     } catch (...) {
17734       {
17735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17736       };
17737     }
17738   }
17739
17740   jresult = result;
17741   return jresult;
17742 }
17743
17744
17745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17746   unsigned int jresult ;
17747   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17748   Dali::Matrix *arg2 = 0 ;
17749   bool result;
17750
17751   arg1 = (Dali::Property::Value *)jarg1;
17752   arg2 = (Dali::Matrix *)jarg2;
17753   if (!arg2) {
17754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17755     return 0;
17756   }
17757   {
17758     try {
17759       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17760     } catch (std::out_of_range& e) {
17761       {
17762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17763       };
17764     } catch (std::exception& e) {
17765       {
17766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17767       };
17768     } catch (Dali::DaliException e) {
17769       {
17770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17771       };
17772     } catch (...) {
17773       {
17774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17775       };
17776     }
17777   }
17778
17779   jresult = result;
17780   return jresult;
17781 }
17782
17783
17784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17785   unsigned int jresult ;
17786   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17787   Dali::AngleAxis *arg2 = 0 ;
17788   bool result;
17789
17790   arg1 = (Dali::Property::Value *)jarg1;
17791   arg2 = (Dali::AngleAxis *)jarg2;
17792   if (!arg2) {
17793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17794     return 0;
17795   }
17796   {
17797     try {
17798       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17799     } catch (std::out_of_range& e) {
17800       {
17801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17802       };
17803     } catch (std::exception& e) {
17804       {
17805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17806       };
17807     } catch (Dali::DaliException e) {
17808       {
17809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17810       };
17811     } catch (...) {
17812       {
17813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17814       };
17815     }
17816   }
17817
17818   jresult = result;
17819   return jresult;
17820 }
17821
17822
17823 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17824   unsigned int jresult ;
17825   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17826   Dali::Quaternion *arg2 = 0 ;
17827   bool result;
17828
17829   arg1 = (Dali::Property::Value *)jarg1;
17830   arg2 = (Dali::Quaternion *)jarg2;
17831   if (!arg2) {
17832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17833     return 0;
17834   }
17835   {
17836     try {
17837       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17838     } catch (std::out_of_range& e) {
17839       {
17840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17841       };
17842     } catch (std::exception& e) {
17843       {
17844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17845       };
17846     } catch (Dali::DaliException e) {
17847       {
17848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17849       };
17850     } catch (...) {
17851       {
17852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17853       };
17854     }
17855   }
17856
17857   jresult = result;
17858   return jresult;
17859 }
17860
17861
17862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17863   unsigned int jresult ;
17864   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17865   std::string *arg2 = 0 ;
17866   bool result;
17867
17868   arg1 = (Dali::Property::Value *)jarg1;
17869
17870   //typemap in
17871   std::string temp;
17872   arg2 = &temp;
17873
17874   {
17875     try {
17876       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17877     } catch (std::out_of_range& e) {
17878       {
17879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17880       };
17881     } catch (std::exception& e) {
17882       {
17883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17884       };
17885     } catch (Dali::DaliException e) {
17886       {
17887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17888       };
17889     } catch (...) {
17890       {
17891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17892       };
17893     }
17894   }
17895
17896   jresult = result;
17897
17898   //Typemap argout in c++ file.
17899   //This will convert c++ string to c# string
17900   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17901
17902   return jresult;
17903 }
17904
17905
17906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17907   unsigned int jresult ;
17908   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17909   Dali::Property::Array *arg2 = 0 ;
17910   bool result;
17911
17912   arg1 = (Dali::Property::Value *)jarg1;
17913   arg2 = (Dali::Property::Array *)jarg2;
17914   if (!arg2) {
17915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17916     return 0;
17917   }
17918   {
17919     try {
17920       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17921     } catch (std::out_of_range& e) {
17922       {
17923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17924       };
17925     } catch (std::exception& e) {
17926       {
17927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17928       };
17929     } catch (Dali::DaliException e) {
17930       {
17931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17932       };
17933     } catch (...) {
17934       {
17935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17936       };
17937     }
17938   }
17939
17940   jresult = result;
17941   return jresult;
17942 }
17943
17944
17945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17946   unsigned int jresult ;
17947   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17948   Dali::Property::Map *arg2 = 0 ;
17949   bool result;
17950
17951   arg1 = (Dali::Property::Value *)jarg1;
17952   arg2 = (Dali::Property::Map *)jarg2;
17953   if (!arg2) {
17954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17955     return 0;
17956   }
17957   {
17958     try {
17959       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17960     } catch (std::out_of_range& e) {
17961       {
17962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17963       };
17964     } catch (std::exception& e) {
17965       {
17966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17967       };
17968     } catch (Dali::DaliException e) {
17969       {
17970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17971       };
17972     } catch (...) {
17973       {
17974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17975       };
17976     }
17977   }
17978
17979   jresult = result;
17980   return jresult;
17981 }
17982
17983
17984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17985   unsigned int jresult ;
17986   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17987   Extents *arg2 = 0 ;
17988   bool result;
17989
17990   arg1 = (Dali::Property::Value *)jarg1;
17991   arg2 = (Extents *)jarg2;
17992   if (!arg2) {
17993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17994     return 0;
17995   }
17996   {
17997     try {
17998       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17999     } catch (std::out_of_range& e) {
18000       {
18001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18002       };
18003     } catch (std::exception& e) {
18004       {
18005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18006       };
18007     } catch (...) {
18008       {
18009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18010       };
18011     }
18012   }
18013   jresult = result;
18014   return jresult;
18015 }
18016
18017
18018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
18019   void * jresult ;
18020   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18021   Dali::Property::Array *result = 0 ;
18022
18023   arg1 = (Dali::Property::Value *)jarg1;
18024   {
18025     try {
18026       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18027     } catch (std::out_of_range& e) {
18028       {
18029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18030       };
18031     } catch (std::exception& e) {
18032       {
18033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18034       };
18035     } catch (Dali::DaliException e) {
18036       {
18037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18038       };
18039     } catch (...) {
18040       {
18041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18042       };
18043     }
18044   }
18045
18046   jresult = (void *)result;
18047   return jresult;
18048 }
18049
18050
18051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18052   void * jresult ;
18053   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18054   Dali::Property::Map *result = 0 ;
18055
18056   arg1 = (Dali::Property::Value *)jarg1;
18057   {
18058     try {
18059       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18060     } catch (std::out_of_range& e) {
18061       {
18062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18063       };
18064     } catch (std::exception& e) {
18065       {
18066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18067       };
18068     } catch (Dali::DaliException e) {
18069       {
18070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18071       };
18072     } catch (...) {
18073       {
18074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18075       };
18076     }
18077   }
18078
18079   jresult = (void *)result;
18080   return jresult;
18081 }
18082
18083
18084 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18085   char * jresult ;
18086   Dali::Property::Type arg1 ;
18087   char *result = 0 ;
18088
18089   arg1 = (Dali::Property::Type)jarg1;
18090   {
18091     try {
18092       result = (char *)Dali::PropertyTypes::GetName(arg1);
18093     } catch (std::out_of_range& e) {
18094       {
18095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18096       };
18097     } catch (std::exception& e) {
18098       {
18099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18100       };
18101     } catch (Dali::DaliException e) {
18102       {
18103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18104       };
18105     } catch (...) {
18106       {
18107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18108       };
18109     }
18110   }
18111
18112   jresult = SWIG_csharp_string_callback((const char *)result);
18113   return jresult;
18114 }
18115
18116
18117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18118   unsigned int jresult ;
18119   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18120   std::string *arg2 = 0 ;
18121   Dali::Property::Map *arg3 = 0 ;
18122   bool result;
18123
18124   arg1 = (Dali::BaseObject *)jarg1;
18125   if (!jarg2) {
18126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18127     return 0;
18128   }
18129   std::string arg2_str(jarg2);
18130   arg2 = &arg2_str;
18131   arg3 = (Dali::Property::Map *)jarg3;
18132   if (!arg3) {
18133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18134     return 0;
18135   }
18136   {
18137     try {
18138       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18139     } catch (std::out_of_range& e) {
18140       {
18141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18142       };
18143     } catch (std::exception& e) {
18144       {
18145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18146       };
18147     } catch (Dali::DaliException e) {
18148       {
18149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18150       };
18151     } catch (...) {
18152       {
18153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18154       };
18155     }
18156   }
18157
18158   jresult = result;
18159
18160   //argout typemap for const std::string&
18161
18162   return jresult;
18163 }
18164
18165
18166 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18167   char * jresult ;
18168   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18169   std::string *result = 0 ;
18170
18171   arg1 = (Dali::BaseObject *)jarg1;
18172   {
18173     try {
18174       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18175     } catch (std::out_of_range& e) {
18176       {
18177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18178       };
18179     } catch (std::exception& e) {
18180       {
18181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18182       };
18183     } catch (Dali::DaliException e) {
18184       {
18185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18186       };
18187     } catch (...) {
18188       {
18189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18190       };
18191     }
18192   }
18193
18194   jresult = SWIG_csharp_string_callback(result->c_str());
18195   return jresult;
18196 }
18197
18198
18199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18200   unsigned int jresult ;
18201   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18202   Dali::TypeInfo *arg2 = 0 ;
18203   bool result;
18204
18205   arg1 = (Dali::BaseObject *)jarg1;
18206   arg2 = (Dali::TypeInfo *)jarg2;
18207   if (!arg2) {
18208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18209     return 0;
18210   }
18211   {
18212     try {
18213       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18214     } catch (std::out_of_range& e) {
18215       {
18216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18217       };
18218     } catch (std::exception& e) {
18219       {
18220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18221       };
18222     } catch (Dali::DaliException e) {
18223       {
18224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18225       };
18226     } catch (...) {
18227       {
18228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18229       };
18230     }
18231   }
18232
18233   jresult = result;
18234   return jresult;
18235 }
18236
18237
18238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18239   unsigned int jresult ;
18240   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18241   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18242   std::string *arg3 = 0 ;
18243   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18244   bool result;
18245
18246   arg1 = (Dali::BaseObject *)jarg1;
18247   arg2 = (ConnectionTrackerInterface *)jarg2;
18248   if (!jarg3) {
18249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18250     return 0;
18251   }
18252   std::string arg3_str(jarg3);
18253   arg3 = &arg3_str;
18254   arg4 = (FunctorDelegate *)jarg4;
18255   {
18256     try {
18257       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18258     } catch (std::out_of_range& e) {
18259       {
18260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18261       };
18262     } catch (std::exception& e) {
18263       {
18264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18265       };
18266     } catch (Dali::DaliException e) {
18267       {
18268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18269       };
18270     } catch (...) {
18271       {
18272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18273       };
18274     }
18275   }
18276
18277   jresult = result;
18278
18279   //argout typemap for const std::string&
18280
18281   return jresult;
18282 }
18283
18284
18285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18286   void * jresult ;
18287   Dali::BaseHandle *arg1 = 0 ;
18288   Dali::BaseObject *result = 0 ;
18289
18290   arg1 = (Dali::BaseHandle *)jarg1;
18291   if (!arg1) {
18292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18293     return 0;
18294   }
18295   {
18296     try {
18297       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18298     } catch (std::out_of_range& e) {
18299       {
18300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18301       };
18302     } catch (std::exception& e) {
18303       {
18304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18305       };
18306     } catch (Dali::DaliException e) {
18307       {
18308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18309       };
18310     } catch (...) {
18311       {
18312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18313       };
18314     }
18315   }
18316
18317   jresult = (void *)result;
18318   return jresult;
18319 }
18320
18321
18322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18323   void * jresult ;
18324   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18325   Dali::BaseHandle *result = 0 ;
18326
18327   arg1 = (Dali::BaseObject *)jarg1;
18328   {
18329     try {
18330       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18331     } catch (std::out_of_range& e) {
18332       {
18333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18334       };
18335     } catch (std::exception& e) {
18336       {
18337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18338       };
18339     } catch (Dali::DaliException e) {
18340       {
18341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18342       };
18343     } catch (...) {
18344       {
18345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18346       };
18347     }
18348   }
18349
18350   jresult = (void *)result;
18351   return jresult;
18352 }
18353
18354
18355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18356   void * jresult ;
18357   Dali::BaseHandle *result = 0 ;
18358
18359   {
18360     try {
18361       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18362     } catch (std::out_of_range& e) {
18363       {
18364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18365       };
18366     } catch (std::exception& e) {
18367       {
18368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18369       };
18370     } catch (Dali::DaliException e) {
18371       {
18372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18373       };
18374     } catch (...) {
18375       {
18376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18377       };
18378     }
18379   }
18380
18381   jresult = (void *)result;
18382   return jresult;
18383 }
18384
18385
18386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18387   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18388
18389   arg1 = (Dali::BaseHandle *)jarg1;
18390   {
18391     try {
18392       delete arg1;
18393     } catch (std::out_of_range& e) {
18394       {
18395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18396       };
18397     } catch (std::exception& e) {
18398       {
18399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18400       };
18401     } catch (Dali::DaliException e) {
18402       {
18403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18404       };
18405     } catch (...) {
18406       {
18407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18408       };
18409     }
18410   }
18411
18412 }
18413
18414
18415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18416   void * jresult ;
18417   Dali::BaseHandle *arg1 = 0 ;
18418   Dali::BaseHandle *result = 0 ;
18419
18420   arg1 = (Dali::BaseHandle *)jarg1;
18421   if (!arg1) {
18422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18423     return 0;
18424   }
18425   {
18426     try {
18427       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18428     } catch (std::out_of_range& e) {
18429       {
18430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18431       };
18432     } catch (std::exception& e) {
18433       {
18434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18435       };
18436     } catch (Dali::DaliException e) {
18437       {
18438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18439       };
18440     } catch (...) {
18441       {
18442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18443       };
18444     }
18445   }
18446
18447   jresult = (void *)result;
18448   return jresult;
18449 }
18450
18451
18452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18453   void * jresult ;
18454   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18455   Dali::BaseHandle *arg2 = 0 ;
18456   Dali::BaseHandle *result = 0 ;
18457
18458   arg1 = (Dali::BaseHandle *)jarg1;
18459   arg2 = (Dali::BaseHandle *)jarg2;
18460   if (!arg2) {
18461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18462     return 0;
18463   }
18464   {
18465     try {
18466       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18467     } catch (std::out_of_range& e) {
18468       {
18469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18470       };
18471     } catch (std::exception& e) {
18472       {
18473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18474       };
18475     } catch (Dali::DaliException e) {
18476       {
18477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18478       };
18479     } catch (...) {
18480       {
18481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18482       };
18483     }
18484   }
18485
18486   jresult = (void *)result;
18487   return jresult;
18488 }
18489
18490
18491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18492   unsigned int jresult ;
18493   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18494   std::string *arg2 = 0 ;
18495   Dali::Property::Map *arg3 = 0 ;
18496   bool result;
18497
18498   arg1 = (Dali::BaseHandle *)jarg1;
18499   if (!jarg2) {
18500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18501     return 0;
18502   }
18503   std::string arg2_str(jarg2);
18504   arg2 = &arg2_str;
18505   arg3 = (Dali::Property::Map *)jarg3;
18506   if (!arg3) {
18507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18508     return 0;
18509   }
18510   {
18511     try {
18512       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18513     } catch (std::out_of_range& e) {
18514       {
18515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18516       };
18517     } catch (std::exception& e) {
18518       {
18519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18520       };
18521     } catch (Dali::DaliException e) {
18522       {
18523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18524       };
18525     } catch (...) {
18526       {
18527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18528       };
18529     }
18530   }
18531
18532   jresult = result;
18533
18534   //argout typemap for const std::string&
18535
18536   return jresult;
18537 }
18538
18539
18540 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18541   char * jresult ;
18542   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18543   std::string *result = 0 ;
18544
18545   arg1 = (Dali::BaseHandle *)jarg1;
18546   {
18547     try {
18548       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18549     } catch (std::out_of_range& e) {
18550       {
18551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18552       };
18553     } catch (std::exception& e) {
18554       {
18555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18556       };
18557     } catch (Dali::DaliException e) {
18558       {
18559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18560       };
18561     } catch (...) {
18562       {
18563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18564       };
18565     }
18566   }
18567
18568   jresult = SWIG_csharp_string_callback(result->c_str());
18569   return jresult;
18570 }
18571
18572
18573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18574   unsigned int jresult ;
18575   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18576   Dali::TypeInfo *arg2 = 0 ;
18577   bool result;
18578
18579   arg1 = (Dali::BaseHandle *)jarg1;
18580   arg2 = (Dali::TypeInfo *)jarg2;
18581   if (!arg2) {
18582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18583     return 0;
18584   }
18585   {
18586     try {
18587       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18588     } catch (std::out_of_range& e) {
18589       {
18590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18591       };
18592     } catch (std::exception& e) {
18593       {
18594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18595       };
18596     } catch (Dali::DaliException e) {
18597       {
18598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18599       };
18600     } catch (...) {
18601       {
18602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18603       };
18604     }
18605   }
18606
18607   jresult = result;
18608   return jresult;
18609 }
18610
18611
18612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18613   void * jresult ;
18614   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18615   Dali::BaseObject *result = 0 ;
18616
18617   arg1 = (Dali::BaseHandle *)jarg1;
18618   {
18619     try {
18620       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18621     } catch (std::out_of_range& e) {
18622       {
18623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18624       };
18625     } catch (std::exception& e) {
18626       {
18627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18628       };
18629     } catch (Dali::DaliException e) {
18630       {
18631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18632       };
18633     } catch (...) {
18634       {
18635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18636       };
18637     }
18638   }
18639
18640   jresult = (void *)result;
18641   return jresult;
18642 }
18643
18644
18645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18646   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18647
18648   arg1 = (Dali::BaseHandle *)jarg1;
18649   {
18650     try {
18651       (arg1)->Reset();
18652     } catch (std::out_of_range& e) {
18653       {
18654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18655       };
18656     } catch (std::exception& e) {
18657       {
18658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18659       };
18660     } catch (Dali::DaliException e) {
18661       {
18662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18663       };
18664     } catch (...) {
18665       {
18666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18667       };
18668     }
18669   }
18670
18671 }
18672
18673
18674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18675   unsigned int jresult ;
18676   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18677   Dali::BaseHandle *arg2 = 0 ;
18678   bool result;
18679
18680   arg1 = (Dali::BaseHandle *)jarg1;
18681   arg2 = (Dali::BaseHandle *)jarg2;
18682   if (!arg2) {
18683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18684     return 0;
18685   }
18686   {
18687     try {
18688       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18689     } catch (std::out_of_range& e) {
18690       {
18691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18692       };
18693     } catch (std::exception& e) {
18694       {
18695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18696       };
18697     } catch (Dali::DaliException e) {
18698       {
18699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18700       };
18701     } catch (...) {
18702       {
18703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18704       };
18705     }
18706   }
18707
18708   jresult = result;
18709   return jresult;
18710 }
18711
18712
18713 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18714   unsigned int jresult ;
18715   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18716   Dali::BaseHandle *arg2 = 0 ;
18717   bool result;
18718
18719   arg1 = (Dali::BaseHandle *)jarg1;
18720   arg2 = (Dali::BaseHandle *)jarg2;
18721   if (!arg2) {
18722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18723     return 0;
18724   }
18725   {
18726     try {
18727       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18728     } catch (std::out_of_range& e) {
18729       {
18730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18731       };
18732     } catch (std::exception& e) {
18733       {
18734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18735       };
18736     } catch (Dali::DaliException e) {
18737       {
18738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18739       };
18740     } catch (...) {
18741       {
18742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18743       };
18744     }
18745   }
18746
18747   jresult = result;
18748   return jresult;
18749 }
18750
18751
18752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18753   void * jresult ;
18754   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18755   Dali::RefObject *result = 0 ;
18756
18757   arg1 = (Dali::BaseHandle *)jarg1;
18758   {
18759     try {
18760       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18761     } catch (std::out_of_range& e) {
18762       {
18763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18764       };
18765     } catch (std::exception& e) {
18766       {
18767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18768       };
18769     } catch (Dali::DaliException e) {
18770       {
18771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18772       };
18773     } catch (...) {
18774       {
18775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18776       };
18777     }
18778   }
18779
18780   jresult = (void *)result;
18781   return jresult;
18782 }
18783
18784
18785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18786   unsigned int jresult ;
18787   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18788   bool result;
18789
18790   arg1 = (Dali::BaseHandle *)jarg1;
18791   {
18792     try {
18793       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18794     } catch (std::out_of_range& e) {
18795       {
18796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18797       };
18798     } catch (std::exception& e) {
18799       {
18800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18801       };
18802     } catch (Dali::DaliException e) {
18803       {
18804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18805       };
18806     } catch (...) {
18807       {
18808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18809       };
18810     }
18811   }
18812
18813   jresult = result;
18814   return jresult;
18815 }
18816
18817
18818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18819   unsigned int jresult ;
18820   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18821   Dali::BaseHandle *arg2 = 0 ;
18822   bool result;
18823
18824   arg1 = (Dali::BaseHandle *)jarg1;
18825   arg2 = (Dali::BaseHandle *)jarg2;
18826   if (!arg2) {
18827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18828     return 0;
18829   }
18830   {
18831     try {
18832       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18833     } catch (std::out_of_range& e) {
18834       {
18835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18836       };
18837     } catch (std::exception& e) {
18838       {
18839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18840       };
18841     } catch (Dali::DaliException e) {
18842       {
18843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18844       };
18845     } catch (...) {
18846       {
18847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18848       };
18849     }
18850   }
18851
18852   jresult = result;
18853   return jresult;
18854 }
18855
18856
18857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18858   unsigned int jresult ;
18859   Dali::BaseHandle *arg1 = 0 ;
18860   Dali::BaseHandle *arg2 = 0 ;
18861   bool result;
18862
18863   arg1 = (Dali::BaseHandle *)jarg1;
18864   if (!arg1) {
18865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18866     return 0;
18867   }
18868   arg2 = (Dali::BaseHandle *)jarg2;
18869   if (!arg2) {
18870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18871     return 0;
18872   }
18873   {
18874     try {
18875       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18876     } catch (std::out_of_range& e) {
18877       {
18878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18879       };
18880     } catch (std::exception& e) {
18881       {
18882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18883       };
18884     } catch (Dali::DaliException e) {
18885       {
18886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18887       };
18888     } catch (...) {
18889       {
18890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18891       };
18892     }
18893   }
18894
18895   jresult = result;
18896   return jresult;
18897 }
18898
18899
18900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18901   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18902
18903   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18904   {
18905     try {
18906       delete arg1;
18907     } catch (std::out_of_range& e) {
18908       {
18909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18910       };
18911     } catch (std::exception& e) {
18912       {
18913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18914       };
18915     } catch (Dali::DaliException e) {
18916       {
18917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18918       };
18919     } catch (...) {
18920       {
18921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18922       };
18923     }
18924   }
18925
18926 }
18927
18928
18929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18930   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18931   SlotObserver *arg2 = (SlotObserver *) 0 ;
18932   CallbackBase *arg3 = (CallbackBase *) 0 ;
18933
18934   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18935   arg2 = (SlotObserver *)jarg2;
18936   arg3 = (CallbackBase *)jarg3;
18937   {
18938     try {
18939       (arg1)->SignalConnected(arg2,arg3);
18940     } catch (std::out_of_range& e) {
18941       {
18942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18943       };
18944     } catch (std::exception& e) {
18945       {
18946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18947       };
18948     } catch (Dali::DaliException e) {
18949       {
18950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18951       };
18952     } catch (...) {
18953       {
18954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18955       };
18956     }
18957   }
18958
18959 }
18960
18961
18962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18963   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18964
18965   arg1 = (Dali::SignalObserver *)jarg1;
18966   {
18967     try {
18968       delete arg1;
18969     } catch (std::out_of_range& e) {
18970       {
18971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18972       };
18973     } catch (std::exception& e) {
18974       {
18975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18976       };
18977     } catch (Dali::DaliException e) {
18978       {
18979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18980       };
18981     } catch (...) {
18982       {
18983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18984       };
18985     }
18986   }
18987
18988 }
18989
18990
18991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18992   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18993   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18994   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18995
18996   arg1 = (Dali::SignalObserver *)jarg1;
18997   arg2 = (Dali::SlotObserver *)jarg2;
18998   arg3 = (Dali::CallbackBase *)jarg3;
18999   {
19000     try {
19001       (arg1)->SignalDisconnected(arg2,arg3);
19002     } catch (std::out_of_range& e) {
19003       {
19004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19005       };
19006     } catch (std::exception& e) {
19007       {
19008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19009       };
19010     } catch (Dali::DaliException e) {
19011       {
19012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19013       };
19014     } catch (...) {
19015       {
19016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19017       };
19018     }
19019   }
19020
19021 }
19022
19023
19024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19025   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19026
19027   arg1 = (Dali::SlotObserver *)jarg1;
19028   {
19029     try {
19030       delete arg1;
19031     } catch (std::out_of_range& e) {
19032       {
19033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19034       };
19035     } catch (std::exception& e) {
19036       {
19037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19038       };
19039     } catch (Dali::DaliException e) {
19040       {
19041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19042       };
19043     } catch (...) {
19044       {
19045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19046       };
19047     }
19048   }
19049
19050 }
19051
19052
19053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19054   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19055   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19056
19057   arg1 = (Dali::SlotObserver *)jarg1;
19058   arg2 = (Dali::CallbackBase *)jarg2;
19059   {
19060     try {
19061       (arg1)->SlotDisconnected(arg2);
19062     } catch (std::out_of_range& e) {
19063       {
19064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19065       };
19066     } catch (std::exception& e) {
19067       {
19068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19069       };
19070     } catch (Dali::DaliException e) {
19071       {
19072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19073       };
19074     } catch (...) {
19075       {
19076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19077       };
19078     }
19079   }
19080
19081 }
19082
19083
19084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19085   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19086
19087   arg1 = (Dali::ConnectionTracker *)jarg1;
19088   {
19089     try {
19090       delete arg1;
19091     } catch (std::out_of_range& e) {
19092       {
19093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19094       };
19095     } catch (std::exception& e) {
19096       {
19097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19098       };
19099     } catch (Dali::DaliException e) {
19100       {
19101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19102       };
19103     } catch (...) {
19104       {
19105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19106       };
19107     }
19108   }
19109
19110 }
19111
19112
19113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19114   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19115
19116   arg1 = (Dali::ConnectionTracker *)jarg1;
19117   {
19118     try {
19119       (arg1)->DisconnectAll();
19120     } catch (std::out_of_range& e) {
19121       {
19122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19123       };
19124     } catch (std::exception& e) {
19125       {
19126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19127       };
19128     } catch (Dali::DaliException e) {
19129       {
19130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19131       };
19132     } catch (...) {
19133       {
19134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19135       };
19136     }
19137   }
19138
19139 }
19140
19141
19142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19143   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19144   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19145   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19146
19147   arg1 = (Dali::ConnectionTracker *)jarg1;
19148   arg2 = (Dali::SlotObserver *)jarg2;
19149   arg3 = (Dali::CallbackBase *)jarg3;
19150   {
19151     try {
19152       (arg1)->SignalConnected(arg2,arg3);
19153     } catch (std::out_of_range& e) {
19154       {
19155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19156       };
19157     } catch (std::exception& e) {
19158       {
19159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19160       };
19161     } catch (Dali::DaliException e) {
19162       {
19163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19164       };
19165     } catch (...) {
19166       {
19167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19168       };
19169     }
19170   }
19171
19172 }
19173
19174
19175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19176   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19177   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19178   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19179
19180   arg1 = (Dali::ConnectionTracker *)jarg1;
19181   arg2 = (Dali::SlotObserver *)jarg2;
19182   arg3 = (Dali::CallbackBase *)jarg3;
19183   {
19184     try {
19185       (arg1)->SignalDisconnected(arg2,arg3);
19186     } catch (std::out_of_range& e) {
19187       {
19188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19189       };
19190     } catch (std::exception& e) {
19191       {
19192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19193       };
19194     } catch (Dali::DaliException e) {
19195       {
19196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19197       };
19198     } catch (...) {
19199       {
19200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19201       };
19202     }
19203   }
19204
19205 }
19206
19207
19208 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19209   unsigned long jresult ;
19210   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19211   std::size_t result;
19212
19213   arg1 = (Dali::ConnectionTracker *)jarg1;
19214   {
19215     try {
19216       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19217     } catch (std::out_of_range& e) {
19218       {
19219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19220       };
19221     } catch (std::exception& e) {
19222       {
19223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19224       };
19225     } catch (Dali::DaliException e) {
19226       {
19227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19228       };
19229     } catch (...) {
19230       {
19231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19232       };
19233     }
19234   }
19235
19236   jresult = (unsigned long)result;
19237   return jresult;
19238 }
19239
19240
19241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19242   void * jresult ;
19243   Dali::ObjectRegistry *result = 0 ;
19244
19245   {
19246     try {
19247       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19248     } catch (std::out_of_range& e) {
19249       {
19250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19251       };
19252     } catch (std::exception& e) {
19253       {
19254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19255       };
19256     } catch (Dali::DaliException e) {
19257       {
19258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19259       };
19260     } catch (...) {
19261       {
19262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19263       };
19264     }
19265   }
19266
19267   jresult = (void *)result;
19268   return jresult;
19269 }
19270
19271
19272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19273   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19274
19275   arg1 = (Dali::ObjectRegistry *)jarg1;
19276   {
19277     try {
19278       delete arg1;
19279     } catch (std::out_of_range& e) {
19280       {
19281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19282       };
19283     } catch (std::exception& e) {
19284       {
19285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19286       };
19287     } catch (Dali::DaliException e) {
19288       {
19289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19290       };
19291     } catch (...) {
19292       {
19293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19294       };
19295     }
19296   }
19297
19298 }
19299
19300
19301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19302   void * jresult ;
19303   Dali::ObjectRegistry *arg1 = 0 ;
19304   Dali::ObjectRegistry *result = 0 ;
19305
19306   arg1 = (Dali::ObjectRegistry *)jarg1;
19307   if (!arg1) {
19308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19309     return 0;
19310   }
19311   {
19312     try {
19313       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19314     } catch (std::out_of_range& e) {
19315       {
19316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19317       };
19318     } catch (std::exception& e) {
19319       {
19320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19321       };
19322     } catch (Dali::DaliException e) {
19323       {
19324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19325       };
19326     } catch (...) {
19327       {
19328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19329       };
19330     }
19331   }
19332
19333   jresult = (void *)result;
19334   return jresult;
19335 }
19336
19337
19338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19339   void * jresult ;
19340   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19341   Dali::ObjectRegistry *arg2 = 0 ;
19342   Dali::ObjectRegistry *result = 0 ;
19343
19344   arg1 = (Dali::ObjectRegistry *)jarg1;
19345   arg2 = (Dali::ObjectRegistry *)jarg2;
19346   if (!arg2) {
19347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19348     return 0;
19349   }
19350   {
19351     try {
19352       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19353     } catch (std::out_of_range& e) {
19354       {
19355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19356       };
19357     } catch (std::exception& e) {
19358       {
19359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19360       };
19361     } catch (Dali::DaliException e) {
19362       {
19363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19364       };
19365     } catch (...) {
19366       {
19367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19368       };
19369     }
19370   }
19371
19372   jresult = (void *)result;
19373   return jresult;
19374 }
19375
19376
19377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19378   void * jresult ;
19379   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19380   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19381
19382   arg1 = (Dali::ObjectRegistry *)jarg1;
19383   {
19384     try {
19385       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19386     } catch (std::out_of_range& e) {
19387       {
19388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19389       };
19390     } catch (std::exception& e) {
19391       {
19392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19393       };
19394     } catch (Dali::DaliException e) {
19395       {
19396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19397       };
19398     } catch (...) {
19399       {
19400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19401       };
19402     }
19403   }
19404
19405   jresult = (void *)result;
19406   return jresult;
19407 }
19408
19409
19410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19411   void * jresult ;
19412   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19413   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19414
19415   arg1 = (Dali::ObjectRegistry *)jarg1;
19416   {
19417     try {
19418       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19419     } catch (std::out_of_range& e) {
19420       {
19421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19422       };
19423     } catch (std::exception& e) {
19424       {
19425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19426       };
19427     } catch (Dali::DaliException e) {
19428       {
19429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19430       };
19431     } catch (...) {
19432       {
19433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19434       };
19435     }
19436   }
19437
19438   jresult = (void *)result;
19439   return jresult;
19440 }
19441
19442
19443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19444   void * jresult ;
19445   Dali::PropertyCondition *result = 0 ;
19446
19447   {
19448     try {
19449       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19450     } catch (std::out_of_range& e) {
19451       {
19452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19453       };
19454     } catch (std::exception& e) {
19455       {
19456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19457       };
19458     } catch (Dali::DaliException e) {
19459       {
19460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19461       };
19462     } catch (...) {
19463       {
19464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19465       };
19466     }
19467   }
19468
19469   jresult = (void *)result;
19470   return jresult;
19471 }
19472
19473
19474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19475   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19476
19477   arg1 = (Dali::PropertyCondition *)jarg1;
19478   {
19479     try {
19480       delete arg1;
19481     } catch (std::out_of_range& e) {
19482       {
19483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19484       };
19485     } catch (std::exception& e) {
19486       {
19487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19488       };
19489     } catch (Dali::DaliException e) {
19490       {
19491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19492       };
19493     } catch (...) {
19494       {
19495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19496       };
19497     }
19498   }
19499
19500 }
19501
19502
19503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19504   void * jresult ;
19505   Dali::PropertyCondition *arg1 = 0 ;
19506   Dali::PropertyCondition *result = 0 ;
19507
19508   arg1 = (Dali::PropertyCondition *)jarg1;
19509   if (!arg1) {
19510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19511     return 0;
19512   }
19513   {
19514     try {
19515       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19516     } catch (std::out_of_range& e) {
19517       {
19518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19519       };
19520     } catch (std::exception& e) {
19521       {
19522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19523       };
19524     } catch (Dali::DaliException e) {
19525       {
19526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19527       };
19528     } catch (...) {
19529       {
19530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19531       };
19532     }
19533   }
19534
19535   jresult = (void *)result;
19536   return jresult;
19537 }
19538
19539
19540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19541   void * jresult ;
19542   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19543   Dali::PropertyCondition *arg2 = 0 ;
19544   Dali::PropertyCondition *result = 0 ;
19545
19546   arg1 = (Dali::PropertyCondition *)jarg1;
19547   arg2 = (Dali::PropertyCondition *)jarg2;
19548   if (!arg2) {
19549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19550     return 0;
19551   }
19552   {
19553     try {
19554       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19555     } catch (std::out_of_range& e) {
19556       {
19557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19558       };
19559     } catch (std::exception& e) {
19560       {
19561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19562       };
19563     } catch (Dali::DaliException e) {
19564       {
19565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19566       };
19567     } catch (...) {
19568       {
19569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19570       };
19571     }
19572   }
19573
19574   jresult = (void *)result;
19575   return jresult;
19576 }
19577
19578
19579 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19580   unsigned long jresult ;
19581   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19582   std::size_t result;
19583
19584   arg1 = (Dali::PropertyCondition *)jarg1;
19585   {
19586     try {
19587       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19588     } catch (std::out_of_range& e) {
19589       {
19590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19591       };
19592     } catch (std::exception& e) {
19593       {
19594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19595       };
19596     } catch (...) {
19597       {
19598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19599       };
19600     }
19601   }
19602   jresult = (unsigned long)result;
19603   return jresult;
19604 }
19605
19606
19607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19608   float jresult ;
19609   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19610   std::size_t arg2 ;
19611   float result;
19612
19613   arg1 = (Dali::PropertyCondition *)jarg1;
19614   arg2 = (std::size_t)jarg2;
19615   {
19616     try {
19617       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19618     } catch (std::out_of_range& e) {
19619       {
19620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19621       };
19622     } catch (std::exception& e) {
19623       {
19624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19625       };
19626     } catch (...) {
19627       {
19628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19629       };
19630     }
19631   }
19632   jresult = result;
19633   return jresult;
19634 }
19635
19636
19637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19638   void * jresult ;
19639   float arg1 ;
19640   Dali::PropertyCondition result;
19641
19642   arg1 = (float)jarg1;
19643   {
19644     try {
19645       result = Dali::LessThanCondition(arg1);
19646     } catch (std::out_of_range& e) {
19647       {
19648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19649       };
19650     } catch (std::exception& e) {
19651       {
19652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19653       };
19654     } catch (Dali::DaliException e) {
19655       {
19656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19657       };
19658     } catch (...) {
19659       {
19660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19661       };
19662     }
19663   }
19664
19665   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19666   return jresult;
19667 }
19668
19669
19670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19671   void * jresult ;
19672   float arg1 ;
19673   Dali::PropertyCondition result;
19674
19675   arg1 = (float)jarg1;
19676   {
19677     try {
19678       result = Dali::GreaterThanCondition(arg1);
19679     } catch (std::out_of_range& e) {
19680       {
19681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19682       };
19683     } catch (std::exception& e) {
19684       {
19685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19686       };
19687     } catch (Dali::DaliException e) {
19688       {
19689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19690       };
19691     } catch (...) {
19692       {
19693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19694       };
19695     }
19696   }
19697
19698   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19699   return jresult;
19700 }
19701
19702
19703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19704   void * jresult ;
19705   float arg1 ;
19706   float arg2 ;
19707   Dali::PropertyCondition result;
19708
19709   arg1 = (float)jarg1;
19710   arg2 = (float)jarg2;
19711   {
19712     try {
19713       result = Dali::InsideCondition(arg1,arg2);
19714     } catch (std::out_of_range& e) {
19715       {
19716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19717       };
19718     } catch (std::exception& e) {
19719       {
19720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19721       };
19722     } catch (Dali::DaliException e) {
19723       {
19724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19725       };
19726     } catch (...) {
19727       {
19728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19729       };
19730     }
19731   }
19732
19733   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19734   return jresult;
19735 }
19736
19737
19738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19739   void * jresult ;
19740   float arg1 ;
19741   float arg2 ;
19742   Dali::PropertyCondition result;
19743
19744   arg1 = (float)jarg1;
19745   arg2 = (float)jarg2;
19746   {
19747     try {
19748       result = Dali::OutsideCondition(arg1,arg2);
19749     } catch (std::out_of_range& e) {
19750       {
19751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19752       };
19753     } catch (std::exception& e) {
19754       {
19755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19756       };
19757     } catch (Dali::DaliException e) {
19758       {
19759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19760       };
19761     } catch (...) {
19762       {
19763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19764       };
19765     }
19766   }
19767
19768   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19769   return jresult;
19770 }
19771
19772
19773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19774   void * jresult ;
19775   float arg1 ;
19776   float arg2 ;
19777   Dali::PropertyCondition result;
19778
19779   arg1 = (float)jarg1;
19780   arg2 = (float)jarg2;
19781   {
19782     try {
19783       result = Dali::StepCondition(arg1,arg2);
19784     } catch (std::out_of_range& e) {
19785       {
19786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19787       };
19788     } catch (std::exception& e) {
19789       {
19790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19791       };
19792     } catch (Dali::DaliException e) {
19793       {
19794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19795       };
19796     } catch (...) {
19797       {
19798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19799       };
19800     }
19801   }
19802
19803   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19804   return jresult;
19805 }
19806
19807
19808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19809   void * jresult ;
19810   float arg1 ;
19811   Dali::PropertyCondition result;
19812
19813   arg1 = (float)jarg1;
19814   {
19815     try {
19816       result = Dali::StepCondition(arg1);
19817     } catch (std::out_of_range& e) {
19818       {
19819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19820       };
19821     } catch (std::exception& e) {
19822       {
19823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19824       };
19825     } catch (Dali::DaliException e) {
19826       {
19827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19828       };
19829     } catch (...) {
19830       {
19831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19832       };
19833     }
19834   }
19835
19836   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19837   return jresult;
19838 }
19839
19840
19841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19842   void * jresult ;
19843   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19844   Dali::PropertyCondition result;
19845
19846   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19847   if (!arg1) {
19848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19849     return 0;
19850   }
19851   {
19852     try {
19853       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19854     } catch (std::out_of_range& e) {
19855       {
19856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19857       };
19858     } catch (std::exception& e) {
19859       {
19860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19861       };
19862     } catch (Dali::DaliException e) {
19863       {
19864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19865       };
19866     } catch (...) {
19867       {
19868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19869       };
19870     }
19871   }
19872
19873   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19874   return jresult;
19875 }
19876
19877
19878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19879   void * jresult ;
19880   Dali::PropertyNotification *result = 0 ;
19881
19882   {
19883     try {
19884       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19885     } catch (std::out_of_range& e) {
19886       {
19887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19888       };
19889     } catch (std::exception& e) {
19890       {
19891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19892       };
19893     } catch (Dali::DaliException e) {
19894       {
19895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19896       };
19897     } catch (...) {
19898       {
19899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19900       };
19901     }
19902   }
19903
19904   jresult = (void *)result;
19905   return jresult;
19906 }
19907
19908
19909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19910   void * jresult ;
19911   Dali::BaseHandle arg1 ;
19912   Dali::BaseHandle *argp1 ;
19913   Dali::PropertyNotification result;
19914
19915   argp1 = (Dali::BaseHandle *)jarg1;
19916   if (!argp1) {
19917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19918     return 0;
19919   }
19920   arg1 = *argp1;
19921   {
19922     try {
19923       result = Dali::PropertyNotification::DownCast(arg1);
19924     } catch (std::out_of_range& e) {
19925       {
19926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19927       };
19928     } catch (std::exception& e) {
19929       {
19930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19931       };
19932     } catch (Dali::DaliException e) {
19933       {
19934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19935       };
19936     } catch (...) {
19937       {
19938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19939       };
19940     }
19941   }
19942
19943   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19944   return jresult;
19945 }
19946
19947
19948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19949   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19950
19951   arg1 = (Dali::PropertyNotification *)jarg1;
19952   {
19953     try {
19954       delete arg1;
19955     } catch (std::out_of_range& e) {
19956       {
19957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19958       };
19959     } catch (std::exception& e) {
19960       {
19961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19962       };
19963     } catch (Dali::DaliException e) {
19964       {
19965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19966       };
19967     } catch (...) {
19968       {
19969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19970       };
19971     }
19972   }
19973
19974 }
19975
19976
19977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19978   void * jresult ;
19979   Dali::PropertyNotification *arg1 = 0 ;
19980   Dali::PropertyNotification *result = 0 ;
19981
19982   arg1 = (Dali::PropertyNotification *)jarg1;
19983   if (!arg1) {
19984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19985     return 0;
19986   }
19987   {
19988     try {
19989       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19990     } catch (std::out_of_range& e) {
19991       {
19992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19993       };
19994     } catch (std::exception& e) {
19995       {
19996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19997       };
19998     } catch (Dali::DaliException e) {
19999       {
20000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20001       };
20002     } catch (...) {
20003       {
20004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20005       };
20006     }
20007   }
20008
20009   jresult = (void *)result;
20010   return jresult;
20011 }
20012
20013
20014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
20015   void * jresult ;
20016   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20017   Dali::PropertyNotification *arg2 = 0 ;
20018   Dali::PropertyNotification *result = 0 ;
20019
20020   arg1 = (Dali::PropertyNotification *)jarg1;
20021   arg2 = (Dali::PropertyNotification *)jarg2;
20022   if (!arg2) {
20023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20024     return 0;
20025   }
20026   {
20027     try {
20028       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20029     } catch (std::out_of_range& e) {
20030       {
20031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20032       };
20033     } catch (std::exception& e) {
20034       {
20035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20036       };
20037     } catch (Dali::DaliException e) {
20038       {
20039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20040       };
20041     } catch (...) {
20042       {
20043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20044       };
20045     }
20046   }
20047
20048   jresult = (void *)result;
20049   return jresult;
20050 }
20051
20052
20053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20054   void * jresult ;
20055   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20056   Dali::PropertyCondition result;
20057
20058   arg1 = (Dali::PropertyNotification *)jarg1;
20059   {
20060     try {
20061       result = (arg1)->GetCondition();
20062     } catch (std::out_of_range& e) {
20063       {
20064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20065       };
20066     } catch (std::exception& e) {
20067       {
20068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20069       };
20070     } catch (Dali::DaliException e) {
20071       {
20072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20073       };
20074     } catch (...) {
20075       {
20076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20077       };
20078     }
20079   }
20080
20081   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20082   return jresult;
20083 }
20084
20085
20086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20087   void * jresult ;
20088   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20089   Dali::Handle result;
20090
20091   arg1 = (Dali::PropertyNotification *)jarg1;
20092   {
20093     try {
20094       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20095     } catch (std::out_of_range& e) {
20096       {
20097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20098       };
20099     } catch (std::exception& e) {
20100       {
20101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20102       };
20103     } catch (Dali::DaliException e) {
20104       {
20105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20106       };
20107     } catch (...) {
20108       {
20109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20110       };
20111     }
20112   }
20113
20114   jresult = new Dali::Handle((const Dali::Handle &)result);
20115   return jresult;
20116 }
20117
20118
20119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20120   int jresult ;
20121   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20122   Dali::Property::Index result;
20123
20124   arg1 = (Dali::PropertyNotification *)jarg1;
20125   {
20126     try {
20127       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20128     } catch (std::out_of_range& e) {
20129       {
20130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20131       };
20132     } catch (std::exception& e) {
20133       {
20134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20135       };
20136     } catch (Dali::DaliException e) {
20137       {
20138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20139       };
20140     } catch (...) {
20141       {
20142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20143       };
20144     }
20145   }
20146
20147   jresult = result;
20148   return jresult;
20149 }
20150
20151
20152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20153   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20154   Dali::PropertyNotification::NotifyMode arg2 ;
20155
20156   arg1 = (Dali::PropertyNotification *)jarg1;
20157   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20158   {
20159     try {
20160       (arg1)->SetNotifyMode(arg2);
20161     } catch (std::out_of_range& e) {
20162       {
20163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20164       };
20165     } catch (std::exception& e) {
20166       {
20167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20168       };
20169     } catch (Dali::DaliException e) {
20170       {
20171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20172       };
20173     } catch (...) {
20174       {
20175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20176       };
20177     }
20178   }
20179
20180 }
20181
20182
20183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20184   int jresult ;
20185   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20186   Dali::PropertyNotification::NotifyMode result;
20187
20188   arg1 = (Dali::PropertyNotification *)jarg1;
20189   {
20190     try {
20191       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20192     } catch (std::out_of_range& e) {
20193       {
20194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20195       };
20196     } catch (std::exception& e) {
20197       {
20198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20199       };
20200     } catch (Dali::DaliException e) {
20201       {
20202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20203       };
20204     } catch (...) {
20205       {
20206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20207       };
20208     }
20209   }
20210
20211   jresult = (int)result;
20212   return jresult;
20213 }
20214
20215
20216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20217   unsigned int jresult ;
20218   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20219   bool result;
20220
20221   arg1 = (Dali::PropertyNotification *)jarg1;
20222   {
20223     try {
20224       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20225     } catch (std::out_of_range& e) {
20226       {
20227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20228       };
20229     } catch (std::exception& e) {
20230       {
20231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20232       };
20233     } catch (Dali::DaliException e) {
20234       {
20235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20236       };
20237     } catch (...) {
20238       {
20239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20240       };
20241     }
20242   }
20243
20244   jresult = result;
20245   return jresult;
20246 }
20247
20248
20249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20250   void * jresult ;
20251   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20252   Dali::PropertyNotifySignalType *result = 0 ;
20253
20254   arg1 = (Dali::PropertyNotification *)jarg1;
20255   {
20256     try {
20257       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20258     } catch (std::out_of_range& e) {
20259       {
20260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20261       };
20262     } catch (std::exception& e) {
20263       {
20264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20265       };
20266     } catch (Dali::DaliException e) {
20267       {
20268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20269       };
20270     } catch (...) {
20271       {
20272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20273       };
20274     }
20275   }
20276
20277   jresult = (void *)result;
20278   return jresult;
20279 }
20280
20281
20282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20283   void * jresult ;
20284   Dali::Handle *result = 0 ;
20285
20286   {
20287     try {
20288       result = (Dali::Handle *)new Dali::Handle();
20289     } catch (std::out_of_range& e) {
20290       {
20291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20292       };
20293     } catch (std::exception& e) {
20294       {
20295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20296       };
20297     } catch (Dali::DaliException e) {
20298       {
20299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20300       };
20301     } catch (...) {
20302       {
20303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20304       };
20305     }
20306   }
20307
20308   jresult = (void *)result;
20309   return jresult;
20310 }
20311
20312
20313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20314   void * jresult ;
20315   Dali::Handle result;
20316
20317   {
20318     try {
20319       result = Dali::Handle::New();
20320     } catch (std::out_of_range& e) {
20321       {
20322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20323       };
20324     } catch (std::exception& e) {
20325       {
20326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20327       };
20328     } catch (Dali::DaliException e) {
20329       {
20330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20331       };
20332     } catch (...) {
20333       {
20334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20335       };
20336     }
20337   }
20338
20339   jresult = new Dali::Handle((const Dali::Handle &)result);
20340   return jresult;
20341 }
20342
20343
20344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20345   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20346
20347   arg1 = (Dali::Handle *)jarg1;
20348   {
20349     try {
20350       delete arg1;
20351     } catch (std::out_of_range& e) {
20352       {
20353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20354       };
20355     } catch (std::exception& e) {
20356       {
20357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20358       };
20359     } catch (Dali::DaliException e) {
20360       {
20361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20362       };
20363     } catch (...) {
20364       {
20365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20366       };
20367     }
20368   }
20369
20370 }
20371
20372
20373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20374   void * jresult ;
20375   Dali::Handle *arg1 = 0 ;
20376   Dali::Handle *result = 0 ;
20377
20378   arg1 = (Dali::Handle *)jarg1;
20379   if (!arg1) {
20380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20381     return 0;
20382   }
20383   {
20384     try {
20385       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20386     } catch (std::out_of_range& e) {
20387       {
20388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20389       };
20390     } catch (std::exception& e) {
20391       {
20392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20393       };
20394     } catch (Dali::DaliException e) {
20395       {
20396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20397       };
20398     } catch (...) {
20399       {
20400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20401       };
20402     }
20403   }
20404
20405   jresult = (void *)result;
20406   return jresult;
20407 }
20408
20409
20410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20411   void * jresult ;
20412   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20413   Dali::Handle *arg2 = 0 ;
20414   Dali::Handle *result = 0 ;
20415
20416   arg1 = (Dali::Handle *)jarg1;
20417   arg2 = (Dali::Handle *)jarg2;
20418   if (!arg2) {
20419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20420     return 0;
20421   }
20422   {
20423     try {
20424       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20425     } catch (std::out_of_range& e) {
20426       {
20427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20428       };
20429     } catch (std::exception& e) {
20430       {
20431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20432       };
20433     } catch (Dali::DaliException e) {
20434       {
20435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20436       };
20437     } catch (...) {
20438       {
20439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20440       };
20441     }
20442   }
20443
20444   jresult = (void *)result;
20445   return jresult;
20446 }
20447
20448
20449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20450   void * jresult ;
20451   Dali::BaseHandle arg1 ;
20452   Dali::BaseHandle *argp1 ;
20453   Dali::Handle result;
20454
20455   argp1 = (Dali::BaseHandle *)jarg1;
20456   if (!argp1) {
20457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20458     return 0;
20459   }
20460   arg1 = *argp1;
20461   {
20462     try {
20463       result = Dali::Handle::DownCast(arg1);
20464     } catch (std::out_of_range& e) {
20465       {
20466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20467       };
20468     } catch (std::exception& e) {
20469       {
20470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20471       };
20472     } catch (Dali::DaliException e) {
20473       {
20474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20475       };
20476     } catch (...) {
20477       {
20478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20479       };
20480     }
20481   }
20482
20483   jresult = new Dali::Handle((const Dali::Handle &)result);
20484   return jresult;
20485 }
20486
20487
20488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20489   unsigned int jresult ;
20490   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20491   Dali::Handle::Capability arg2 ;
20492   bool result;
20493
20494   arg1 = (Dali::Handle *)jarg1;
20495   arg2 = (Dali::Handle::Capability)jarg2;
20496   {
20497     try {
20498       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20499     } catch (std::out_of_range& e) {
20500       {
20501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20502       };
20503     } catch (std::exception& e) {
20504       {
20505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20506       };
20507     } catch (Dali::DaliException e) {
20508       {
20509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20510       };
20511     } catch (...) {
20512       {
20513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20514       };
20515     }
20516   }
20517
20518   jresult = result;
20519   return jresult;
20520 }
20521
20522
20523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20524   unsigned int jresult ;
20525   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20526   unsigned int result;
20527
20528   arg1 = (Dali::Handle *)jarg1;
20529   {
20530     try {
20531       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20532     } catch (std::out_of_range& e) {
20533       {
20534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20535       };
20536     } catch (std::exception& e) {
20537       {
20538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20539       };
20540     } catch (Dali::DaliException e) {
20541       {
20542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20543       };
20544     } catch (...) {
20545       {
20546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20547       };
20548     }
20549   }
20550
20551   jresult = result;
20552   return jresult;
20553 }
20554
20555
20556 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20557   char * jresult ;
20558   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20559   Dali::Property::Index arg2 ;
20560   std::string result;
20561
20562   arg1 = (Dali::Handle *)jarg1;
20563   arg2 = (Dali::Property::Index)jarg2;
20564   {
20565     try {
20566       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20567     } catch (std::out_of_range& e) {
20568       {
20569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20570       };
20571     } catch (std::exception& e) {
20572       {
20573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20574       };
20575     } catch (Dali::DaliException e) {
20576       {
20577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20578       };
20579     } catch (...) {
20580       {
20581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20582       };
20583     }
20584   }
20585
20586   jresult = SWIG_csharp_string_callback((&result)->c_str());
20587   return jresult;
20588 }
20589
20590
20591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20592   int jresult ;
20593   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20594   std::string *arg2 = 0 ;
20595   Dali::Property::Index result;
20596
20597   arg1 = (Dali::Handle *)jarg1;
20598   if (!jarg2) {
20599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20600     return 0;
20601   }
20602   std::string arg2_str(jarg2);
20603   arg2 = &arg2_str;
20604   {
20605     try {
20606       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*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
20628   //argout typemap for const std::string&
20629
20630   return jresult;
20631 }
20632
20633
20634 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20635   unsigned int jresult ;
20636   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20637   Dali::Property::Index arg2 ;
20638   bool result;
20639
20640   arg1 = (Dali::Handle *)jarg1;
20641   arg2 = (Dali::Property::Index)jarg2;
20642   {
20643     try {
20644       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20645     } catch (std::out_of_range& e) {
20646       {
20647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20648       };
20649     } catch (std::exception& e) {
20650       {
20651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20652       };
20653     } catch (Dali::DaliException e) {
20654       {
20655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20656       };
20657     } catch (...) {
20658       {
20659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20660       };
20661     }
20662   }
20663
20664   jresult = result;
20665   return jresult;
20666 }
20667
20668
20669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20670   unsigned int jresult ;
20671   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20672   Dali::Property::Index arg2 ;
20673   bool result;
20674
20675   arg1 = (Dali::Handle *)jarg1;
20676   arg2 = (Dali::Property::Index)jarg2;
20677   {
20678     try {
20679       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20680     } catch (std::out_of_range& e) {
20681       {
20682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20683       };
20684     } catch (std::exception& e) {
20685       {
20686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20687       };
20688     } catch (Dali::DaliException e) {
20689       {
20690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20691       };
20692     } catch (...) {
20693       {
20694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20695       };
20696     }
20697   }
20698
20699   jresult = result;
20700   return jresult;
20701 }
20702
20703
20704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20705   unsigned int jresult ;
20706   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20707   Dali::Property::Index arg2 ;
20708   bool result;
20709
20710   arg1 = (Dali::Handle *)jarg1;
20711   arg2 = (Dali::Property::Index)jarg2;
20712   {
20713     try {
20714       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20715     } catch (std::out_of_range& e) {
20716       {
20717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20718       };
20719     } catch (std::exception& e) {
20720       {
20721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20722       };
20723     } catch (Dali::DaliException e) {
20724       {
20725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20726       };
20727     } catch (...) {
20728       {
20729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20730       };
20731     }
20732   }
20733
20734   jresult = result;
20735   return jresult;
20736 }
20737
20738
20739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20740   int jresult ;
20741   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20742   Dali::Property::Index arg2 ;
20743   Dali::Property::Type result;
20744
20745   arg1 = (Dali::Handle *)jarg1;
20746   arg2 = (Dali::Property::Index)jarg2;
20747   {
20748     try {
20749       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20750     } catch (std::out_of_range& e) {
20751       {
20752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20753       };
20754     } catch (std::exception& e) {
20755       {
20756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20757       };
20758     } catch (Dali::DaliException e) {
20759       {
20760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20761       };
20762     } catch (...) {
20763       {
20764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20765       };
20766     }
20767   }
20768
20769   jresult = (int)result;
20770   return jresult;
20771 }
20772
20773
20774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20775   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20776   Dali::Property::Index arg2 ;
20777   Dali::Property::Value *arg3 = 0 ;
20778
20779   arg1 = (Dali::Handle *)jarg1;
20780   arg2 = (Dali::Property::Index)jarg2;
20781   arg3 = (Dali::Property::Value *)jarg3;
20782   if (!arg3) {
20783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20784     return ;
20785   }
20786   {
20787     try {
20788       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20789     } catch (std::out_of_range& e) {
20790       {
20791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20792       };
20793     } catch (std::exception& e) {
20794       {
20795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20796       };
20797     } catch (Dali::DaliException e) {
20798       {
20799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20800       };
20801     } catch (...) {
20802       {
20803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20804       };
20805     }
20806   }
20807
20808 }
20809
20810
20811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20812   int jresult ;
20813   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20814   std::string *arg2 = 0 ;
20815   Dali::Property::Value *arg3 = 0 ;
20816   Dali::Property::Index result;
20817
20818   arg1 = (Dali::Handle *)jarg1;
20819   if (!jarg2) {
20820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20821     return 0;
20822   }
20823   std::string arg2_str(jarg2);
20824   arg2 = &arg2_str;
20825   arg3 = (Dali::Property::Value *)jarg3;
20826   if (!arg3) {
20827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20828     return 0;
20829   }
20830   {
20831     try {
20832       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20833     } catch (std::out_of_range& e) {
20834       {
20835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20836       };
20837     } catch (std::exception& e) {
20838       {
20839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20840       };
20841     } catch (Dali::DaliException e) {
20842       {
20843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20844       };
20845     } catch (...) {
20846       {
20847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20848       };
20849     }
20850   }
20851
20852   jresult = result;
20853
20854   //argout typemap for const std::string&
20855
20856   return jresult;
20857 }
20858
20859
20860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20861   int jresult ;
20862   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20863   std::string *arg2 = 0 ;
20864   Dali::Property::Value *arg3 = 0 ;
20865   Dali::Property::AccessMode arg4 ;
20866   Dali::Property::Index result;
20867
20868   arg1 = (Dali::Handle *)jarg1;
20869   if (!jarg2) {
20870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20871     return 0;
20872   }
20873   std::string arg2_str(jarg2);
20874   arg2 = &arg2_str;
20875   arg3 = (Dali::Property::Value *)jarg3;
20876   if (!arg3) {
20877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20878     return 0;
20879   }
20880   arg4 = (Dali::Property::AccessMode)jarg4;
20881   {
20882     try {
20883       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
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 = result;
20904
20905   //argout typemap for const std::string&
20906
20907   return jresult;
20908 }
20909
20910
20911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20912   void * jresult ;
20913   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20914   Dali::Property::Index arg2 ;
20915   Dali::Property::Value result;
20916
20917   arg1 = (Dali::Handle *)jarg1;
20918   arg2 = (Dali::Property::Index)jarg2;
20919   {
20920     try {
20921       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20922     } catch (std::out_of_range& e) {
20923       {
20924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20925       };
20926     } catch (std::exception& e) {
20927       {
20928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20929       };
20930     } catch (Dali::DaliException e) {
20931       {
20932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20933       };
20934     } catch (...) {
20935       {
20936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20937       };
20938     }
20939   }
20940
20941   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20942   return jresult;
20943 }
20944
20945
20946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20947   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20948   Dali::Property::IndexContainer *arg2 = 0 ;
20949
20950   arg1 = (Dali::Handle *)jarg1;
20951   arg2 = (Dali::Property::IndexContainer *)jarg2;
20952   if (!arg2) {
20953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20954     return ;
20955   }
20956   {
20957     try {
20958       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20959     } catch (std::out_of_range& e) {
20960       {
20961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20962       };
20963     } catch (std::exception& e) {
20964       {
20965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20966       };
20967     } catch (Dali::DaliException e) {
20968       {
20969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20970       };
20971     } catch (...) {
20972       {
20973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20974       };
20975     }
20976   }
20977
20978 }
20979
20980
20981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20982   void * jresult ;
20983   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20984   Dali::Property::Index arg2 ;
20985   Dali::PropertyCondition *arg3 = 0 ;
20986   Dali::PropertyNotification result;
20987
20988   arg1 = (Dali::Handle *)jarg1;
20989   arg2 = (Dali::Property::Index)jarg2;
20990   arg3 = (Dali::PropertyCondition *)jarg3;
20991   if (!arg3) {
20992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20993     return 0;
20994   }
20995   {
20996     try {
20997       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20998     } catch (std::out_of_range& e) {
20999       {
21000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21001       };
21002     } catch (std::exception& e) {
21003       {
21004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21005       };
21006     } catch (Dali::DaliException e) {
21007       {
21008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21009       };
21010     } catch (...) {
21011       {
21012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21013       };
21014     }
21015   }
21016
21017   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21018   return jresult;
21019 }
21020
21021
21022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21023   void * jresult ;
21024   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21025   Dali::Property::Index arg2 ;
21026   int arg3 ;
21027   Dali::PropertyCondition *arg4 = 0 ;
21028   Dali::PropertyNotification result;
21029
21030   arg1 = (Dali::Handle *)jarg1;
21031   arg2 = (Dali::Property::Index)jarg2;
21032   arg3 = (int)jarg3;
21033   arg4 = (Dali::PropertyCondition *)jarg4;
21034   if (!arg4) {
21035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21036     return 0;
21037   }
21038   {
21039     try {
21040       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21041     } catch (std::out_of_range& e) {
21042       {
21043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21044       };
21045     } catch (std::exception& e) {
21046       {
21047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21048       };
21049     } catch (Dali::DaliException e) {
21050       {
21051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21052       };
21053     } catch (...) {
21054       {
21055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21056       };
21057     }
21058   }
21059
21060   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21061   return jresult;
21062 }
21063
21064
21065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21066   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21067   Dali::PropertyNotification arg2 ;
21068   Dali::PropertyNotification *argp2 ;
21069
21070   arg1 = (Dali::Handle *)jarg1;
21071   argp2 = (Dali::PropertyNotification *)jarg2;
21072   if (!argp2) {
21073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21074     return ;
21075   }
21076   arg2 = *argp2;
21077   {
21078     try {
21079       (arg1)->RemovePropertyNotification(arg2);
21080     } catch (std::out_of_range& e) {
21081       {
21082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21083       };
21084     } catch (std::exception& e) {
21085       {
21086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21087       };
21088     } catch (Dali::DaliException e) {
21089       {
21090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21091       };
21092     } catch (...) {
21093       {
21094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21095       };
21096     }
21097   }
21098
21099 }
21100
21101
21102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21103   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21104
21105   arg1 = (Dali::Handle *)jarg1;
21106   {
21107     try {
21108       (arg1)->RemovePropertyNotifications();
21109     } catch (std::out_of_range& e) {
21110       {
21111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21112       };
21113     } catch (std::exception& e) {
21114       {
21115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21116       };
21117     } catch (Dali::DaliException e) {
21118       {
21119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21120       };
21121     } catch (...) {
21122       {
21123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21124       };
21125     }
21126   }
21127
21128 }
21129
21130
21131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21132   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21133
21134   arg1 = (Dali::Handle *)jarg1;
21135   {
21136     try {
21137       (arg1)->RemoveConstraints();
21138     } catch (std::out_of_range& e) {
21139       {
21140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21141       };
21142     } catch (std::exception& e) {
21143       {
21144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21145       };
21146     } catch (Dali::DaliException e) {
21147       {
21148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21149       };
21150     } catch (...) {
21151       {
21152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21153       };
21154     }
21155   }
21156
21157 }
21158
21159
21160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21161   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21162   unsigned int arg2 ;
21163
21164   arg1 = (Dali::Handle *)jarg1;
21165   arg2 = (unsigned int)jarg2;
21166   {
21167     try {
21168       (arg1)->RemoveConstraints(arg2);
21169     } catch (std::out_of_range& e) {
21170       {
21171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21172       };
21173     } catch (std::exception& e) {
21174       {
21175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21176       };
21177     } catch (Dali::DaliException e) {
21178       {
21179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21180       };
21181     } catch (...) {
21182       {
21183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21184       };
21185     }
21186   }
21187
21188 }
21189
21190
21191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21192   int jresult ;
21193   Dali::Property::Index result;
21194
21195   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21196   jresult = result;
21197   return jresult;
21198 }
21199
21200
21201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21202   void * jresult ;
21203   Dali::Handle result;
21204
21205   {
21206     try {
21207       result = Dali::WeightObject::New();
21208     } catch (std::out_of_range& e) {
21209       {
21210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21211       };
21212     } catch (std::exception& e) {
21213       {
21214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21215       };
21216     } catch (Dali::DaliException e) {
21217       {
21218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21219       };
21220     } catch (...) {
21221       {
21222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21223       };
21224     }
21225   }
21226
21227   jresult = new Dali::Handle((const Dali::Handle &)result);
21228   return jresult;
21229 }
21230
21231
21232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21233   void * jresult ;
21234   Dali::TypeInfo *result = 0 ;
21235
21236   {
21237     try {
21238       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21239     } catch (std::out_of_range& e) {
21240       {
21241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21242       };
21243     } catch (std::exception& e) {
21244       {
21245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21246       };
21247     } catch (Dali::DaliException e) {
21248       {
21249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21250       };
21251     } catch (...) {
21252       {
21253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21254       };
21255     }
21256   }
21257
21258   jresult = (void *)result;
21259   return jresult;
21260 }
21261
21262
21263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21264   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21265
21266   arg1 = (Dali::TypeInfo *)jarg1;
21267   {
21268     try {
21269       delete arg1;
21270     } catch (std::out_of_range& e) {
21271       {
21272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21273       };
21274     } catch (std::exception& e) {
21275       {
21276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21277       };
21278     } catch (Dali::DaliException e) {
21279       {
21280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21281       };
21282     } catch (...) {
21283       {
21284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21285       };
21286     }
21287   }
21288
21289 }
21290
21291
21292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21293   void * jresult ;
21294   Dali::TypeInfo *arg1 = 0 ;
21295   Dali::TypeInfo *result = 0 ;
21296
21297   arg1 = (Dali::TypeInfo *)jarg1;
21298   if (!arg1) {
21299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21300     return 0;
21301   }
21302   {
21303     try {
21304       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21305     } catch (std::out_of_range& e) {
21306       {
21307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21308       };
21309     } catch (std::exception& e) {
21310       {
21311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21312       };
21313     } catch (Dali::DaliException e) {
21314       {
21315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21316       };
21317     } catch (...) {
21318       {
21319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21320       };
21321     }
21322   }
21323
21324   jresult = (void *)result;
21325   return jresult;
21326 }
21327
21328
21329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21330   void * jresult ;
21331   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21332   Dali::TypeInfo *arg2 = 0 ;
21333   Dali::TypeInfo *result = 0 ;
21334
21335   arg1 = (Dali::TypeInfo *)jarg1;
21336   arg2 = (Dali::TypeInfo *)jarg2;
21337   if (!arg2) {
21338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21339     return 0;
21340   }
21341   {
21342     try {
21343       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21344     } catch (std::out_of_range& e) {
21345       {
21346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21347       };
21348     } catch (std::exception& e) {
21349       {
21350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21351       };
21352     } catch (Dali::DaliException e) {
21353       {
21354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21355       };
21356     } catch (...) {
21357       {
21358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21359       };
21360     }
21361   }
21362
21363   jresult = (void *)result;
21364   return jresult;
21365 }
21366
21367
21368 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21369   char * jresult ;
21370   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21371   std::string *result = 0 ;
21372
21373   arg1 = (Dali::TypeInfo *)jarg1;
21374   {
21375     try {
21376       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21377     } catch (std::out_of_range& e) {
21378       {
21379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21380       };
21381     } catch (std::exception& e) {
21382       {
21383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21384       };
21385     } catch (Dali::DaliException e) {
21386       {
21387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21388       };
21389     } catch (...) {
21390       {
21391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21392       };
21393     }
21394   }
21395
21396   jresult = SWIG_csharp_string_callback(result->c_str());
21397   return jresult;
21398 }
21399
21400
21401 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21402   char * jresult ;
21403   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21404   std::string *result = 0 ;
21405
21406   arg1 = (Dali::TypeInfo *)jarg1;
21407   {
21408     try {
21409       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21410     } catch (std::out_of_range& e) {
21411       {
21412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21413       };
21414     } catch (std::exception& e) {
21415       {
21416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21417       };
21418     } catch (Dali::DaliException e) {
21419       {
21420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21421       };
21422     } catch (...) {
21423       {
21424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21425       };
21426     }
21427   }
21428
21429   jresult = SWIG_csharp_string_callback(result->c_str());
21430   return jresult;
21431 }
21432
21433
21434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21435   void * jresult ;
21436   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21437   Dali::BaseHandle result;
21438
21439   arg1 = (Dali::TypeInfo *)jarg1;
21440   {
21441     try {
21442       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21443     } catch (std::out_of_range& e) {
21444       {
21445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21446       };
21447     } catch (std::exception& e) {
21448       {
21449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21450       };
21451     } catch (Dali::DaliException e) {
21452       {
21453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21454       };
21455     } catch (...) {
21456       {
21457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21458       };
21459     }
21460   }
21461
21462   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21463   return jresult;
21464 }
21465
21466
21467 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21468   unsigned long jresult ;
21469   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21470   size_t result;
21471
21472   arg1 = (Dali::TypeInfo *)jarg1;
21473   {
21474     try {
21475       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21476     } catch (std::out_of_range& e) {
21477       {
21478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21479       };
21480     } catch (std::exception& e) {
21481       {
21482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21483       };
21484     } catch (Dali::DaliException e) {
21485       {
21486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21487       };
21488     } catch (...) {
21489       {
21490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21491       };
21492     }
21493   }
21494
21495   jresult = (unsigned long)result;
21496   return jresult;
21497 }
21498
21499
21500 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21501   char * jresult ;
21502   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21503   size_t arg2 ;
21504   std::string result;
21505
21506   arg1 = (Dali::TypeInfo *)jarg1;
21507   arg2 = (size_t)jarg2;
21508   {
21509     try {
21510       result = (arg1)->GetActionName(arg2);
21511     } catch (std::out_of_range& e) {
21512       {
21513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21514       };
21515     } catch (std::exception& e) {
21516       {
21517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21518       };
21519     } catch (Dali::DaliException e) {
21520       {
21521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21522       };
21523     } catch (...) {
21524       {
21525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21526       };
21527     }
21528   }
21529
21530   jresult = SWIG_csharp_string_callback((&result)->c_str());
21531   return jresult;
21532 }
21533
21534
21535 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21536   unsigned long jresult ;
21537   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21538   size_t result;
21539
21540   arg1 = (Dali::TypeInfo *)jarg1;
21541   {
21542     try {
21543       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21544     } catch (std::out_of_range& e) {
21545       {
21546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21547       };
21548     } catch (std::exception& e) {
21549       {
21550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21551       };
21552     } catch (Dali::DaliException e) {
21553       {
21554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21555       };
21556     } catch (...) {
21557       {
21558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21559       };
21560     }
21561   }
21562
21563   jresult = (unsigned long)result;
21564   return jresult;
21565 }
21566
21567
21568 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21569   char * jresult ;
21570   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21571   size_t arg2 ;
21572   std::string result;
21573
21574   arg1 = (Dali::TypeInfo *)jarg1;
21575   arg2 = (size_t)jarg2;
21576   {
21577     try {
21578       result = (arg1)->GetSignalName(arg2);
21579     } catch (std::out_of_range& e) {
21580       {
21581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21582       };
21583     } catch (std::exception& e) {
21584       {
21585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21586       };
21587     } catch (Dali::DaliException e) {
21588       {
21589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21590       };
21591     } catch (...) {
21592       {
21593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21594       };
21595     }
21596   }
21597
21598   jresult = SWIG_csharp_string_callback((&result)->c_str());
21599   return jresult;
21600 }
21601
21602
21603 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21604   unsigned long jresult ;
21605   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21606   size_t result;
21607
21608   arg1 = (Dali::TypeInfo *)jarg1;
21609   {
21610     try {
21611       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21612     } catch (std::out_of_range& e) {
21613       {
21614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21615       };
21616     } catch (std::exception& e) {
21617       {
21618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21619       };
21620     } catch (Dali::DaliException e) {
21621       {
21622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21623       };
21624     } catch (...) {
21625       {
21626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21627       };
21628     }
21629   }
21630
21631   jresult = (unsigned long)result;
21632   return jresult;
21633 }
21634
21635
21636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21637   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21638   Dali::Property::IndexContainer *arg2 = 0 ;
21639
21640   arg1 = (Dali::TypeInfo *)jarg1;
21641   arg2 = (Dali::Property::IndexContainer *)jarg2;
21642   if (!arg2) {
21643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21644     return ;
21645   }
21646   {
21647     try {
21648       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21649     } catch (std::out_of_range& e) {
21650       {
21651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21652       };
21653     } catch (std::exception& e) {
21654       {
21655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21656       };
21657     } catch (Dali::DaliException e) {
21658       {
21659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21660       };
21661     } catch (...) {
21662       {
21663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21664       };
21665     }
21666   }
21667
21668 }
21669
21670
21671 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21672   char * jresult ;
21673   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21674   Dali::Property::Index arg2 ;
21675   std::string *result = 0 ;
21676
21677   arg1 = (Dali::TypeInfo *)jarg1;
21678   arg2 = (Dali::Property::Index)jarg2;
21679   {
21680     try {
21681       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21682     } catch (std::out_of_range& e) {
21683       {
21684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21685       };
21686     } catch (std::exception& e) {
21687       {
21688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21689       };
21690     } catch (Dali::DaliException e) {
21691       {
21692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21693       };
21694     } catch (...) {
21695       {
21696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21697       };
21698     }
21699   }
21700
21701   jresult = SWIG_csharp_string_callback(result->c_str());
21702   return jresult;
21703 }
21704
21705
21706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21707   void * jresult ;
21708   Dali::TypeRegistry result;
21709
21710   {
21711     try {
21712       result = Dali::TypeRegistry::Get();
21713     } catch (std::out_of_range& e) {
21714       {
21715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21716       };
21717     } catch (std::exception& e) {
21718       {
21719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21720       };
21721     } catch (Dali::DaliException e) {
21722       {
21723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21724       };
21725     } catch (...) {
21726       {
21727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21728       };
21729     }
21730   }
21731
21732   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21733   return jresult;
21734 }
21735
21736
21737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21738   void * jresult ;
21739   Dali::TypeRegistry *result = 0 ;
21740
21741   {
21742     try {
21743       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21744     } catch (std::out_of_range& e) {
21745       {
21746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21747       };
21748     } catch (std::exception& e) {
21749       {
21750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21751       };
21752     } catch (Dali::DaliException e) {
21753       {
21754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21755       };
21756     } catch (...) {
21757       {
21758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21759       };
21760     }
21761   }
21762
21763   jresult = (void *)result;
21764   return jresult;
21765 }
21766
21767
21768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21769   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21770
21771   arg1 = (Dali::TypeRegistry *)jarg1;
21772   {
21773     try {
21774       delete arg1;
21775     } catch (std::out_of_range& e) {
21776       {
21777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21778       };
21779     } catch (std::exception& e) {
21780       {
21781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21782       };
21783     } catch (Dali::DaliException e) {
21784       {
21785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21786       };
21787     } catch (...) {
21788       {
21789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21790       };
21791     }
21792   }
21793
21794 }
21795
21796
21797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21798   void * jresult ;
21799   Dali::TypeRegistry *arg1 = 0 ;
21800   Dali::TypeRegistry *result = 0 ;
21801
21802   arg1 = (Dali::TypeRegistry *)jarg1;
21803   if (!arg1) {
21804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21805     return 0;
21806   }
21807   {
21808     try {
21809       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21810     } catch (std::out_of_range& e) {
21811       {
21812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21813       };
21814     } catch (std::exception& e) {
21815       {
21816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21817       };
21818     } catch (Dali::DaliException e) {
21819       {
21820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21821       };
21822     } catch (...) {
21823       {
21824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21825       };
21826     }
21827   }
21828
21829   jresult = (void *)result;
21830   return jresult;
21831 }
21832
21833
21834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21835   void * jresult ;
21836   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21837   Dali::TypeRegistry *arg2 = 0 ;
21838   Dali::TypeRegistry *result = 0 ;
21839
21840   arg1 = (Dali::TypeRegistry *)jarg1;
21841   arg2 = (Dali::TypeRegistry *)jarg2;
21842   if (!arg2) {
21843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21844     return 0;
21845   }
21846   {
21847     try {
21848       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21849     } catch (std::out_of_range& e) {
21850       {
21851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21852       };
21853     } catch (std::exception& e) {
21854       {
21855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21856       };
21857     } catch (Dali::DaliException e) {
21858       {
21859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21860       };
21861     } catch (...) {
21862       {
21863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21864       };
21865     }
21866   }
21867
21868   jresult = (void *)result;
21869   return jresult;
21870 }
21871
21872
21873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21874   void * jresult ;
21875   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21876   std::string *arg2 = 0 ;
21877   Dali::TypeInfo result;
21878
21879   arg1 = (Dali::TypeRegistry *)jarg1;
21880   if (!jarg2) {
21881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21882     return 0;
21883   }
21884   std::string arg2_str(jarg2);
21885   arg2 = &arg2_str;
21886   {
21887     try {
21888       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21889     } catch (std::out_of_range& e) {
21890       {
21891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21892       };
21893     } catch (std::exception& e) {
21894       {
21895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21896       };
21897     } catch (Dali::DaliException e) {
21898       {
21899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21900       };
21901     } catch (...) {
21902       {
21903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21904       };
21905     }
21906   }
21907
21908   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21909
21910   //argout typemap for const std::string&
21911
21912   return jresult;
21913 }
21914
21915
21916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21917   void * jresult ;
21918   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21919   std::type_info *arg2 = 0 ;
21920   Dali::TypeInfo result;
21921
21922   arg1 = (Dali::TypeRegistry *)jarg1;
21923   arg2 = (std::type_info *)jarg2;
21924   if (!arg2) {
21925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21926     return 0;
21927   }
21928   {
21929     try {
21930       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21931     } catch (std::out_of_range& e) {
21932       {
21933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21934       };
21935     } catch (std::exception& e) {
21936       {
21937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21938       };
21939     } catch (Dali::DaliException e) {
21940       {
21941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21942       };
21943     } catch (...) {
21944       {
21945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21946       };
21947     }
21948   }
21949
21950   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21951   return jresult;
21952 }
21953
21954
21955 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21956   unsigned long jresult ;
21957   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21958   size_t result;
21959
21960   arg1 = (Dali::TypeRegistry *)jarg1;
21961   {
21962     try {
21963       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21964     } catch (std::out_of_range& e) {
21965       {
21966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21967       };
21968     } catch (std::exception& e) {
21969       {
21970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21971       };
21972     } catch (Dali::DaliException e) {
21973       {
21974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21975       };
21976     } catch (...) {
21977       {
21978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21979       };
21980     }
21981   }
21982
21983   jresult = (unsigned long)result;
21984   return jresult;
21985 }
21986
21987
21988 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21989   char * jresult ;
21990   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21991   size_t arg2 ;
21992   std::string result;
21993
21994   arg1 = (Dali::TypeRegistry *)jarg1;
21995   arg2 = (size_t)jarg2;
21996   {
21997     try {
21998       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21999     } catch (std::out_of_range& e) {
22000       {
22001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22002       };
22003     } catch (std::exception& e) {
22004       {
22005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22006       };
22007     } catch (Dali::DaliException e) {
22008       {
22009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22010       };
22011     } catch (...) {
22012       {
22013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22014       };
22015     }
22016   }
22017
22018   jresult = SWIG_csharp_string_callback((&result)->c_str());
22019   return jresult;
22020 }
22021
22022
22023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22024   void * jresult ;
22025   std::type_info *arg1 = 0 ;
22026   std::type_info *arg2 = 0 ;
22027   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22028   Dali::TypeRegistration *result = 0 ;
22029
22030   arg1 = (std::type_info *)jarg1;
22031   if (!arg1) {
22032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22033     return 0;
22034   }
22035   arg2 = (std::type_info *)jarg2;
22036   if (!arg2) {
22037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22038     return 0;
22039   }
22040   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22041   {
22042     try {
22043       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22044     } catch (std::out_of_range& e) {
22045       {
22046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22047       };
22048     } catch (std::exception& e) {
22049       {
22050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22051       };
22052     } catch (Dali::DaliException e) {
22053       {
22054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22055       };
22056     } catch (...) {
22057       {
22058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22059       };
22060     }
22061   }
22062
22063   jresult = (void *)result;
22064   return jresult;
22065 }
22066
22067
22068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22069   void * jresult ;
22070   std::type_info *arg1 = 0 ;
22071   std::type_info *arg2 = 0 ;
22072   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22073   bool arg4 ;
22074   Dali::TypeRegistration *result = 0 ;
22075
22076   arg1 = (std::type_info *)jarg1;
22077   if (!arg1) {
22078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22079     return 0;
22080   }
22081   arg2 = (std::type_info *)jarg2;
22082   if (!arg2) {
22083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22084     return 0;
22085   }
22086   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22087   arg4 = jarg4 ? true : false;
22088   {
22089     try {
22090       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22091     } catch (std::out_of_range& e) {
22092       {
22093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22094       };
22095     } catch (std::exception& e) {
22096       {
22097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22098       };
22099     } catch (Dali::DaliException e) {
22100       {
22101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22102       };
22103     } catch (...) {
22104       {
22105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22106       };
22107     }
22108   }
22109
22110   jresult = (void *)result;
22111   return jresult;
22112 }
22113
22114
22115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22116   void * jresult ;
22117   std::string *arg1 = 0 ;
22118   std::type_info *arg2 = 0 ;
22119   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22120   Dali::TypeRegistration *result = 0 ;
22121
22122   if (!jarg1) {
22123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22124     return 0;
22125   }
22126   std::string arg1_str(jarg1);
22127   arg1 = &arg1_str;
22128   arg2 = (std::type_info *)jarg2;
22129   if (!arg2) {
22130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22131     return 0;
22132   }
22133   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22134   {
22135     try {
22136       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22137     } catch (std::out_of_range& e) {
22138       {
22139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22140       };
22141     } catch (std::exception& e) {
22142       {
22143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22144       };
22145     } catch (Dali::DaliException e) {
22146       {
22147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22148       };
22149     } catch (...) {
22150       {
22151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22152       };
22153     }
22154   }
22155
22156   jresult = (void *)result;
22157
22158   //argout typemap for const std::string&
22159
22160   return jresult;
22161 }
22162
22163
22164 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22165   char * jresult ;
22166   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22167   std::string result;
22168
22169   arg1 = (Dali::TypeRegistration *)jarg1;
22170   {
22171     try {
22172       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22173     } catch (std::out_of_range& e) {
22174       {
22175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22176       };
22177     } catch (std::exception& e) {
22178       {
22179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22180       };
22181     } catch (Dali::DaliException e) {
22182       {
22183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22184       };
22185     } catch (...) {
22186       {
22187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22188       };
22189     }
22190   }
22191
22192   jresult = SWIG_csharp_string_callback((&result)->c_str());
22193   return jresult;
22194 }
22195
22196
22197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22198   std::string *arg1 = 0 ;
22199   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22200
22201   if (!jarg1) {
22202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22203     return ;
22204   }
22205   std::string arg1_str(jarg1);
22206   arg1 = &arg1_str;
22207   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22208   {
22209     try {
22210       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22211     } catch (std::out_of_range& e) {
22212       {
22213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22214       };
22215     } catch (std::exception& e) {
22216       {
22217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22218       };
22219     } catch (Dali::DaliException e) {
22220       {
22221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22222       };
22223     } catch (...) {
22224       {
22225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22226       };
22227     }
22228   }
22229
22230
22231   //argout typemap for const std::string&
22232
22233 }
22234
22235
22236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22237   std::string *arg1 = 0 ;
22238   std::string *arg2 = 0 ;
22239   int arg3 ;
22240   Dali::Property::Type arg4 ;
22241   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22242   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22243
22244   if (!jarg1) {
22245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22246     return ;
22247   }
22248   std::string arg1_str(jarg1);
22249   arg1 = &arg1_str;
22250   if (!jarg2) {
22251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22252     return ;
22253   }
22254   std::string arg2_str(jarg2);
22255   arg2 = &arg2_str;
22256   arg3 = (int)jarg3;
22257   arg4 = (Dali::Property::Type)jarg4;
22258   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22259   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22260   {
22261     try {
22262       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22263     } catch (std::out_of_range& e) {
22264       {
22265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22266       };
22267     } catch (std::exception& e) {
22268       {
22269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22270       };
22271     } catch (Dali::DaliException e) {
22272       {
22273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22274       };
22275     } catch (...) {
22276       {
22277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22278       };
22279     }
22280   }
22281
22282
22283   //argout typemap for const std::string&
22284
22285
22286   //argout typemap for const std::string&
22287
22288 }
22289
22290
22291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22292   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22293
22294   arg1 = (Dali::TypeRegistration *)jarg1;
22295   {
22296     try {
22297       delete arg1;
22298     } catch (std::out_of_range& e) {
22299       {
22300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22301       };
22302     } catch (std::exception& e) {
22303       {
22304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22305       };
22306     } catch (Dali::DaliException e) {
22307       {
22308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22309       };
22310     } catch (...) {
22311       {
22312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22313       };
22314     }
22315   }
22316
22317 }
22318
22319
22320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22321   void * jresult ;
22322   Dali::TypeRegistration *arg1 = 0 ;
22323   std::string *arg2 = 0 ;
22324   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22325   Dali::SignalConnectorType *result = 0 ;
22326
22327   arg1 = (Dali::TypeRegistration *)jarg1;
22328   if (!arg1) {
22329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22330     return 0;
22331   }
22332   if (!jarg2) {
22333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22334     return 0;
22335   }
22336   std::string arg2_str(jarg2);
22337   arg2 = &arg2_str;
22338   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22339   {
22340     try {
22341       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22342     } catch (std::out_of_range& e) {
22343       {
22344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22345       };
22346     } catch (std::exception& e) {
22347       {
22348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22349       };
22350     } catch (Dali::DaliException e) {
22351       {
22352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22353       };
22354     } catch (...) {
22355       {
22356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22357       };
22358     }
22359   }
22360
22361   jresult = (void *)result;
22362
22363   //argout typemap for const std::string&
22364
22365   return jresult;
22366 }
22367
22368
22369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22370   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22371
22372   arg1 = (Dali::SignalConnectorType *)jarg1;
22373   {
22374     try {
22375       delete arg1;
22376     } catch (std::out_of_range& e) {
22377       {
22378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22379       };
22380     } catch (std::exception& e) {
22381       {
22382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22383       };
22384     } catch (Dali::DaliException e) {
22385       {
22386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22387       };
22388     } catch (...) {
22389       {
22390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22391       };
22392     }
22393   }
22394
22395 }
22396
22397
22398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22399   void * jresult ;
22400   Dali::TypeRegistration *arg1 = 0 ;
22401   std::string *arg2 = 0 ;
22402   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22403   Dali::TypeAction *result = 0 ;
22404
22405   arg1 = (Dali::TypeRegistration *)jarg1;
22406   if (!arg1) {
22407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22408     return 0;
22409   }
22410   if (!jarg2) {
22411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22412     return 0;
22413   }
22414   std::string arg2_str(jarg2);
22415   arg2 = &arg2_str;
22416   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22417   {
22418     try {
22419       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22420     } catch (std::out_of_range& e) {
22421       {
22422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22423       };
22424     } catch (std::exception& e) {
22425       {
22426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22427       };
22428     } catch (Dali::DaliException e) {
22429       {
22430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22431       };
22432     } catch (...) {
22433       {
22434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22435       };
22436     }
22437   }
22438
22439   jresult = (void *)result;
22440
22441   //argout typemap for const std::string&
22442
22443   return jresult;
22444 }
22445
22446
22447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22448   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22449
22450   arg1 = (Dali::TypeAction *)jarg1;
22451   {
22452     try {
22453       delete arg1;
22454     } catch (std::out_of_range& e) {
22455       {
22456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22457       };
22458     } catch (std::exception& e) {
22459       {
22460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22461       };
22462     } catch (Dali::DaliException e) {
22463       {
22464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22465       };
22466     } catch (...) {
22467       {
22468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22469       };
22470     }
22471   }
22472
22473 }
22474
22475
22476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22477   void * jresult ;
22478   Dali::TypeRegistration *arg1 = 0 ;
22479   std::string *arg2 = 0 ;
22480   Dali::Property::Index arg3 ;
22481   Dali::Property::Type arg4 ;
22482   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22483   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22484   Dali::PropertyRegistration *result = 0 ;
22485
22486   arg1 = (Dali::TypeRegistration *)jarg1;
22487   if (!arg1) {
22488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22489     return 0;
22490   }
22491   if (!jarg2) {
22492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22493     return 0;
22494   }
22495   std::string arg2_str(jarg2);
22496   arg2 = &arg2_str;
22497   arg3 = (Dali::Property::Index)jarg3;
22498   arg4 = (Dali::Property::Type)jarg4;
22499   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22500   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22501   {
22502     try {
22503       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22504     } catch (std::out_of_range& e) {
22505       {
22506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22507       };
22508     } catch (std::exception& e) {
22509       {
22510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22511       };
22512     } catch (Dali::DaliException e) {
22513       {
22514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22515       };
22516     } catch (...) {
22517       {
22518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22519       };
22520     }
22521   }
22522
22523   jresult = (void *)result;
22524
22525   //argout typemap for const std::string&
22526
22527   return jresult;
22528 }
22529
22530
22531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22532   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22533
22534   arg1 = (Dali::PropertyRegistration *)jarg1;
22535   {
22536     try {
22537       delete arg1;
22538     } catch (std::out_of_range& e) {
22539       {
22540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22541       };
22542     } catch (std::exception& e) {
22543       {
22544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22545       };
22546     } catch (Dali::DaliException e) {
22547       {
22548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22549       };
22550     } catch (...) {
22551       {
22552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22553       };
22554     }
22555   }
22556
22557 }
22558
22559
22560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22561   void * jresult ;
22562   Dali::TypeRegistration *arg1 = 0 ;
22563   std::string *arg2 = 0 ;
22564   Dali::Property::Index arg3 ;
22565   Dali::Property::Type arg4 ;
22566   Dali::AnimatablePropertyRegistration *result = 0 ;
22567
22568   arg1 = (Dali::TypeRegistration *)jarg1;
22569   if (!arg1) {
22570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22571     return 0;
22572   }
22573   if (!jarg2) {
22574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22575     return 0;
22576   }
22577   std::string arg2_str(jarg2);
22578   arg2 = &arg2_str;
22579   arg3 = (Dali::Property::Index)jarg3;
22580   arg4 = (Dali::Property::Type)jarg4;
22581   {
22582     try {
22583       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22584     } catch (std::out_of_range& e) {
22585       {
22586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22587       };
22588     } catch (std::exception& e) {
22589       {
22590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22591       };
22592     } catch (Dali::DaliException e) {
22593       {
22594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22595       };
22596     } catch (...) {
22597       {
22598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22599       };
22600     }
22601   }
22602
22603   jresult = (void *)result;
22604
22605   //argout typemap for const std::string&
22606
22607   return jresult;
22608 }
22609
22610
22611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22612   void * jresult ;
22613   Dali::TypeRegistration *arg1 = 0 ;
22614   std::string *arg2 = 0 ;
22615   Dali::Property::Index arg3 ;
22616   Dali::Property::Value *arg4 = 0 ;
22617   Dali::AnimatablePropertyRegistration *result = 0 ;
22618
22619   arg1 = (Dali::TypeRegistration *)jarg1;
22620   if (!arg1) {
22621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22622     return 0;
22623   }
22624   if (!jarg2) {
22625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22626     return 0;
22627   }
22628   std::string arg2_str(jarg2);
22629   arg2 = &arg2_str;
22630   arg3 = (Dali::Property::Index)jarg3;
22631   arg4 = (Dali::Property::Value *)jarg4;
22632   if (!arg4) {
22633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22634     return 0;
22635   }
22636   {
22637     try {
22638       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22639     } catch (std::out_of_range& e) {
22640       {
22641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22642       };
22643     } catch (std::exception& e) {
22644       {
22645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22646       };
22647     } catch (Dali::DaliException e) {
22648       {
22649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22650       };
22651     } catch (...) {
22652       {
22653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22654       };
22655     }
22656   }
22657
22658   jresult = (void *)result;
22659
22660   //argout typemap for const std::string&
22661
22662   return jresult;
22663 }
22664
22665
22666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22667   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22668
22669   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22670   {
22671     try {
22672       delete arg1;
22673     } catch (std::out_of_range& e) {
22674       {
22675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22676       };
22677     } catch (std::exception& e) {
22678       {
22679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22680       };
22681     } catch (Dali::DaliException e) {
22682       {
22683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22684       };
22685     } catch (...) {
22686       {
22687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22688       };
22689     }
22690   }
22691
22692 }
22693
22694
22695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22696   void * jresult ;
22697   Dali::TypeRegistration *arg1 = 0 ;
22698   std::string *arg2 = 0 ;
22699   Dali::Property::Index arg3 ;
22700   Dali::Property::Index arg4 ;
22701   unsigned int arg5 ;
22702   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22703
22704   arg1 = (Dali::TypeRegistration *)jarg1;
22705   if (!arg1) {
22706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22707     return 0;
22708   }
22709   if (!jarg2) {
22710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22711     return 0;
22712   }
22713   std::string arg2_str(jarg2);
22714   arg2 = &arg2_str;
22715   arg3 = (Dali::Property::Index)jarg3;
22716   arg4 = (Dali::Property::Index)jarg4;
22717   arg5 = (unsigned int)jarg5;
22718   {
22719     try {
22720       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22721     } catch (std::out_of_range& e) {
22722       {
22723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22724       };
22725     } catch (std::exception& e) {
22726       {
22727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22728       };
22729     } catch (Dali::DaliException e) {
22730       {
22731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22732       };
22733     } catch (...) {
22734       {
22735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22736       };
22737     }
22738   }
22739
22740   jresult = (void *)result;
22741
22742   //argout typemap for const std::string&
22743
22744   return jresult;
22745 }
22746
22747
22748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22749   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22750
22751   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22752   {
22753     try {
22754       delete arg1;
22755     } catch (std::out_of_range& e) {
22756       {
22757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22758       };
22759     } catch (std::exception& e) {
22760       {
22761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22762       };
22763     } catch (Dali::DaliException e) {
22764       {
22765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22766       };
22767     } catch (...) {
22768       {
22769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22770       };
22771     }
22772   }
22773
22774 }
22775
22776
22777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22778   void * jresult ;
22779   Dali::TypeRegistration *arg1 = 0 ;
22780   std::string *arg2 = 0 ;
22781   Dali::Property::Index arg3 ;
22782   Dali::Property::Type arg4 ;
22783   Dali::ChildPropertyRegistration *result = 0 ;
22784
22785   arg1 = (Dali::TypeRegistration *)jarg1;
22786   if (!arg1) {
22787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22788     return 0;
22789   }
22790   if (!jarg2) {
22791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22792     return 0;
22793   }
22794   std::string arg2_str(jarg2);
22795   arg2 = &arg2_str;
22796   arg3 = (Dali::Property::Index)jarg3;
22797   arg4 = (Dali::Property::Type)jarg4;
22798   {
22799     try {
22800       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22801     } catch (std::out_of_range& e) {
22802       {
22803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22804       };
22805     } catch (std::exception& e) {
22806       {
22807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22808       };
22809     } catch (Dali::DaliException e) {
22810       {
22811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22812       };
22813     } catch (...) {
22814       {
22815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22816       };
22817     }
22818   }
22819
22820   jresult = (void *)result;
22821
22822   //argout typemap for const std::string&
22823
22824   return jresult;
22825 }
22826
22827
22828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22829   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22830
22831   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22832   {
22833     try {
22834       delete arg1;
22835     } catch (std::out_of_range& e) {
22836       {
22837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22838       };
22839     } catch (std::exception& e) {
22840       {
22841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22842       };
22843     } catch (Dali::DaliException e) {
22844       {
22845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22846       };
22847     } catch (...) {
22848       {
22849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22850       };
22851     }
22852   }
22853
22854 }
22855
22856
22857 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22858   unsigned int jresult ;
22859   std::string *arg1 = 0 ;
22860   std::type_info *arg2 = 0 ;
22861   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22862   bool result;
22863
22864   if (!jarg1) {
22865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22866     return 0;
22867   }
22868   std::string arg1_str(jarg1);
22869   arg1 = &arg1_str;
22870   arg2 = (std::type_info *)jarg2;
22871   if (!arg2) {
22872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22873     return 0;
22874   }
22875   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22876   {
22877     try {
22878       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22879     } catch (std::out_of_range& e) {
22880       {
22881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22882       };
22883     } catch (std::exception& e) {
22884       {
22885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22886       };
22887     } catch (Dali::DaliException e) {
22888       {
22889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22890       };
22891     } catch (...) {
22892       {
22893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22894       };
22895     }
22896   }
22897
22898   jresult = result;
22899
22900   //argout typemap for const std::string&
22901
22902   return jresult;
22903 }
22904
22905
22906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22907   unsigned int jresult ;
22908   std::string *arg1 = 0 ;
22909   std::string *arg2 = 0 ;
22910   Dali::Property::Index arg3 ;
22911   Dali::Property::Type arg4 ;
22912   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22913   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22914   bool result;
22915
22916   if (!jarg1) {
22917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22918     return 0;
22919   }
22920   std::string arg1_str(jarg1);
22921   arg1 = &arg1_str;
22922   if (!jarg2) {
22923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22924     return 0;
22925   }
22926   std::string arg2_str(jarg2);
22927   arg2 = &arg2_str;
22928   arg3 = (Dali::Property::Index)jarg3;
22929   arg4 = (Dali::Property::Type)jarg4;
22930   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22931   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22932   {
22933     try {
22934       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22935     } catch (std::out_of_range& e) {
22936       {
22937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22938       };
22939     } catch (std::exception& e) {
22940       {
22941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22942       };
22943     } catch (Dali::DaliException e) {
22944       {
22945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22946       };
22947     } catch (...) {
22948       {
22949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22950       };
22951     }
22952   }
22953
22954   jresult = result;
22955
22956   //argout typemap for const std::string&
22957
22958
22959   //argout typemap for const std::string&
22960
22961   return jresult;
22962 }
22963
22964
22965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22966   float jresult ;
22967   float result;
22968
22969   result = (float)(float)Dali::ParentOrigin::TOP;
22970   jresult = result;
22971   return jresult;
22972 }
22973
22974
22975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22976   float jresult ;
22977   float result;
22978
22979   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22980   jresult = result;
22981   return jresult;
22982 }
22983
22984
22985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22986   float jresult ;
22987   float result;
22988
22989   result = (float)(float)Dali::ParentOrigin::LEFT;
22990   jresult = result;
22991   return jresult;
22992 }
22993
22994
22995 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22996   float jresult ;
22997   float result;
22998
22999   result = (float)(float)Dali::ParentOrigin::RIGHT;
23000   jresult = result;
23001   return jresult;
23002 }
23003
23004
23005 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
23006   float jresult ;
23007   float result;
23008
23009   result = (float)(float)Dali::ParentOrigin::MIDDLE;
23010   jresult = result;
23011   return jresult;
23012 }
23013
23014
23015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
23016   void * jresult ;
23017   Dali::Vector3 *result = 0 ;
23018
23019   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23020   jresult = (void *)result;
23021   return jresult;
23022 }
23023
23024
23025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23026   void * jresult ;
23027   Dali::Vector3 *result = 0 ;
23028
23029   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23030   jresult = (void *)result;
23031   return jresult;
23032 }
23033
23034
23035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23036   void * jresult ;
23037   Dali::Vector3 *result = 0 ;
23038
23039   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23040   jresult = (void *)result;
23041   return jresult;
23042 }
23043
23044
23045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23046   void * jresult ;
23047   Dali::Vector3 *result = 0 ;
23048
23049   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23050   jresult = (void *)result;
23051   return jresult;
23052 }
23053
23054
23055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23056   void * jresult ;
23057   Dali::Vector3 *result = 0 ;
23058
23059   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23060   jresult = (void *)result;
23061   return jresult;
23062 }
23063
23064
23065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23066   void * jresult ;
23067   Dali::Vector3 *result = 0 ;
23068
23069   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23070   jresult = (void *)result;
23071   return jresult;
23072 }
23073
23074
23075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23076   void * jresult ;
23077   Dali::Vector3 *result = 0 ;
23078
23079   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23080   jresult = (void *)result;
23081   return jresult;
23082 }
23083
23084
23085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23086   void * jresult ;
23087   Dali::Vector3 *result = 0 ;
23088
23089   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23090   jresult = (void *)result;
23091   return jresult;
23092 }
23093
23094
23095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23096   void * jresult ;
23097   Dali::Vector3 *result = 0 ;
23098
23099   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23100   jresult = (void *)result;
23101   return jresult;
23102 }
23103
23104
23105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23106   float jresult ;
23107   float result;
23108
23109   result = (float)(float)Dali::AnchorPoint::TOP;
23110   jresult = result;
23111   return jresult;
23112 }
23113
23114
23115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23116   float jresult ;
23117   float result;
23118
23119   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23120   jresult = result;
23121   return jresult;
23122 }
23123
23124
23125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23126   float jresult ;
23127   float result;
23128
23129   result = (float)(float)Dali::AnchorPoint::LEFT;
23130   jresult = result;
23131   return jresult;
23132 }
23133
23134
23135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23136   float jresult ;
23137   float result;
23138
23139   result = (float)(float)Dali::AnchorPoint::RIGHT;
23140   jresult = result;
23141   return jresult;
23142 }
23143
23144
23145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23146   float jresult ;
23147   float result;
23148
23149   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23150   jresult = result;
23151   return jresult;
23152 }
23153
23154
23155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23156   void * jresult ;
23157   Dali::Vector3 *result = 0 ;
23158
23159   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23160   jresult = (void *)result;
23161   return jresult;
23162 }
23163
23164
23165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23166   void * jresult ;
23167   Dali::Vector3 *result = 0 ;
23168
23169   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23170   jresult = (void *)result;
23171   return jresult;
23172 }
23173
23174
23175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23176   void * jresult ;
23177   Dali::Vector3 *result = 0 ;
23178
23179   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23180   jresult = (void *)result;
23181   return jresult;
23182 }
23183
23184
23185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23186   void * jresult ;
23187   Dali::Vector3 *result = 0 ;
23188
23189   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23190   jresult = (void *)result;
23191   return jresult;
23192 }
23193
23194
23195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23196   void * jresult ;
23197   Dali::Vector3 *result = 0 ;
23198
23199   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23200   jresult = (void *)result;
23201   return jresult;
23202 }
23203
23204
23205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23206   void * jresult ;
23207   Dali::Vector3 *result = 0 ;
23208
23209   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23210   jresult = (void *)result;
23211   return jresult;
23212 }
23213
23214
23215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23216   void * jresult ;
23217   Dali::Vector3 *result = 0 ;
23218
23219   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23220   jresult = (void *)result;
23221   return jresult;
23222 }
23223
23224
23225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23226   void * jresult ;
23227   Dali::Vector3 *result = 0 ;
23228
23229   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23230   jresult = (void *)result;
23231   return jresult;
23232 }
23233
23234
23235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23236   void * jresult ;
23237   Dali::Vector3 *result = 0 ;
23238
23239   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23240   jresult = (void *)result;
23241   return jresult;
23242 }
23243
23244
23245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23246   void * jresult ;
23247   Dali::Vector4 *result = 0 ;
23248
23249   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23250   jresult = (void *)result;
23251   return jresult;
23252 }
23253
23254
23255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23256   void * jresult ;
23257   Dali::Vector4 *result = 0 ;
23258
23259   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23260   jresult = (void *)result;
23261   return jresult;
23262 }
23263
23264
23265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23266   void * jresult ;
23267   Dali::Vector4 *result = 0 ;
23268
23269   result = (Dali::Vector4 *)&Dali::Color::RED;
23270   jresult = (void *)result;
23271   return jresult;
23272 }
23273
23274
23275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23276   void * jresult ;
23277   Dali::Vector4 *result = 0 ;
23278
23279   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23280   jresult = (void *)result;
23281   return jresult;
23282 }
23283
23284
23285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23286   void * jresult ;
23287   Dali::Vector4 *result = 0 ;
23288
23289   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23290   jresult = (void *)result;
23291   return jresult;
23292 }
23293
23294
23295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23296   void * jresult ;
23297   Dali::Vector4 *result = 0 ;
23298
23299   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23300   jresult = (void *)result;
23301   return jresult;
23302 }
23303
23304
23305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23306   void * jresult ;
23307   Dali::Vector4 *result = 0 ;
23308
23309   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23310   jresult = (void *)result;
23311   return jresult;
23312 }
23313
23314
23315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23316   void * jresult ;
23317   Dali::Vector4 *result = 0 ;
23318
23319   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23320   jresult = (void *)result;
23321   return jresult;
23322 }
23323
23324
23325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23326   void * jresult ;
23327   Dali::Vector4 *result = 0 ;
23328
23329   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23330   jresult = (void *)result;
23331   return jresult;
23332 }
23333
23334
23335 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23336   float jresult ;
23337   float result;
23338
23339   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23340   jresult = result;
23341   return jresult;
23342 }
23343
23344
23345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23346   float jresult ;
23347   float result;
23348
23349   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23350   jresult = result;
23351   return jresult;
23352 }
23353
23354
23355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23356   float jresult ;
23357   float result;
23358
23359   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23360   jresult = result;
23361   return jresult;
23362 }
23363
23364
23365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23366   float jresult ;
23367   float result;
23368
23369   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23370   jresult = result;
23371   return jresult;
23372 }
23373
23374
23375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23376   float jresult ;
23377   float result;
23378
23379   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23380   jresult = result;
23381   return jresult;
23382 }
23383
23384
23385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23386   float jresult ;
23387   float result;
23388
23389   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23390   jresult = result;
23391   return jresult;
23392 }
23393
23394
23395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23396   float jresult ;
23397   float result;
23398
23399   result = (float)(float)Dali::Math::PI;
23400   jresult = result;
23401   return jresult;
23402 }
23403
23404
23405 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23406   float jresult ;
23407   float result;
23408
23409   result = (float)(float)Dali::Math::PI_2;
23410   jresult = result;
23411   return jresult;
23412 }
23413
23414
23415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23416   float jresult ;
23417   float result;
23418
23419   result = (float)(float)Dali::Math::PI_4;
23420   jresult = result;
23421   return jresult;
23422 }
23423
23424
23425 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23426   float jresult ;
23427   float result;
23428
23429   result = (float)(float)Dali::Math::PI_OVER_180;
23430   jresult = result;
23431   return jresult;
23432 }
23433
23434
23435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23436   float jresult ;
23437   float result;
23438
23439   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23440   jresult = result;
23441   return jresult;
23442 }
23443
23444
23445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23446   int jresult ;
23447   Dali::ResizePolicy::Type result;
23448
23449   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23450   jresult = (int)result;
23451   return jresult;
23452 }
23453
23454
23455 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23456   unsigned long jresult ;
23457   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23458   Dali::VectorBase::SizeType result;
23459
23460   arg1 = (Dali::VectorBase *)jarg1;
23461   {
23462     try {
23463       result = ((Dali::VectorBase const *)arg1)->Count();
23464     } catch (std::out_of_range& e) {
23465       {
23466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23467       };
23468     } catch (std::exception& e) {
23469       {
23470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23471       };
23472     } catch (Dali::DaliException e) {
23473       {
23474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23475       };
23476     } catch (...) {
23477       {
23478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23479       };
23480     }
23481   }
23482
23483   jresult = (unsigned long)result;
23484   return jresult;
23485 }
23486
23487
23488 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23489   unsigned long jresult ;
23490   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23491   Dali::VectorBase::SizeType result;
23492
23493   arg1 = (Dali::VectorBase *)jarg1;
23494   {
23495     try {
23496       result = ((Dali::VectorBase const *)arg1)->Size();
23497     } catch (std::out_of_range& e) {
23498       {
23499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23500       };
23501     } catch (std::exception& e) {
23502       {
23503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23504       };
23505     } catch (Dali::DaliException e) {
23506       {
23507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23508       };
23509     } catch (...) {
23510       {
23511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23512       };
23513     }
23514   }
23515
23516   jresult = (unsigned long)result;
23517   return jresult;
23518 }
23519
23520
23521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23522   unsigned int jresult ;
23523   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23524   bool result;
23525
23526   arg1 = (Dali::VectorBase *)jarg1;
23527   {
23528     try {
23529       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23530     } catch (std::out_of_range& e) {
23531       {
23532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23533       };
23534     } catch (std::exception& e) {
23535       {
23536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23537       };
23538     } catch (Dali::DaliException e) {
23539       {
23540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23541       };
23542     } catch (...) {
23543       {
23544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23545       };
23546     }
23547   }
23548
23549   jresult = result;
23550   return jresult;
23551 }
23552
23553
23554 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23555   unsigned long jresult ;
23556   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23557   Dali::VectorBase::SizeType result;
23558
23559   arg1 = (Dali::VectorBase *)jarg1;
23560   {
23561     try {
23562       result = ((Dali::VectorBase const *)arg1)->Capacity();
23563     } catch (std::out_of_range& e) {
23564       {
23565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23566       };
23567     } catch (std::exception& e) {
23568       {
23569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23570       };
23571     } catch (Dali::DaliException e) {
23572       {
23573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23574       };
23575     } catch (...) {
23576       {
23577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23578       };
23579     }
23580   }
23581
23582   jresult = (unsigned long)result;
23583   return jresult;
23584 }
23585
23586
23587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23588   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23589
23590   arg1 = (Dali::VectorBase *)jarg1;
23591   {
23592     try {
23593       (arg1)->Release();
23594     } catch (std::out_of_range& e) {
23595       {
23596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23597       };
23598     } catch (std::exception& e) {
23599       {
23600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23601       };
23602     } catch (Dali::DaliException e) {
23603       {
23604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23605       };
23606     } catch (...) {
23607       {
23608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23609       };
23610     }
23611   }
23612
23613 }
23614
23615
23616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23617   int jresult ;
23618   Dali::Pixel::Format result;
23619
23620   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23621   jresult = (int)result;
23622   return jresult;
23623 }
23624
23625
23626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23627   int jresult ;
23628   Dali::Pixel::Format result;
23629
23630   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23631   jresult = (int)result;
23632   return jresult;
23633 }
23634
23635
23636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23637   unsigned int jresult ;
23638   Dali::Pixel::Format arg1 ;
23639   bool result;
23640
23641   arg1 = (Dali::Pixel::Format)jarg1;
23642   {
23643     try {
23644       result = (bool)Dali::Pixel::HasAlpha(arg1);
23645     } catch (std::out_of_range& e) {
23646       {
23647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23648       };
23649     } catch (std::exception& e) {
23650       {
23651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23652       };
23653     } catch (Dali::DaliException e) {
23654       {
23655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23656       };
23657     } catch (...) {
23658       {
23659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23660       };
23661     }
23662   }
23663
23664   jresult = result;
23665   return jresult;
23666 }
23667
23668
23669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23670   unsigned int jresult ;
23671   Dali::Pixel::Format arg1 ;
23672   unsigned int result;
23673
23674   arg1 = (Dali::Pixel::Format)jarg1;
23675   {
23676     try {
23677       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23678     } catch (std::out_of_range& e) {
23679       {
23680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23681       };
23682     } catch (std::exception& e) {
23683       {
23684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23685       };
23686     } catch (Dali::DaliException e) {
23687       {
23688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23689       };
23690     } catch (...) {
23691       {
23692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23693       };
23694     }
23695   }
23696
23697   jresult = result;
23698   return jresult;
23699 }
23700
23701
23702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23703   Dali::Pixel::Format arg1 ;
23704   int *arg2 = 0 ;
23705   int *arg3 = 0 ;
23706
23707   arg1 = (Dali::Pixel::Format)jarg1;
23708   arg2 = (int *)jarg2;
23709   if (!arg2) {
23710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23711     return ;
23712   }
23713   arg3 = (int *)jarg3;
23714   if (!arg3) {
23715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23716     return ;
23717   }
23718   {
23719     try {
23720       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23721     } catch (std::out_of_range& e) {
23722       {
23723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23724       };
23725     } catch (std::exception& e) {
23726       {
23727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23728       };
23729     } catch (Dali::DaliException e) {
23730       {
23731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23732       };
23733     } catch (...) {
23734       {
23735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23736       };
23737     }
23738   }
23739
23740 }
23741
23742
23743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23744   void * jresult ;
23745   unsigned char *arg1 = (unsigned char *) 0 ;
23746   unsigned int arg2 ;
23747   unsigned int arg3 ;
23748   unsigned int arg4 ;
23749   Dali::Pixel::Format arg5 ;
23750   Dali::PixelData::ReleaseFunction arg6 ;
23751   Dali::PixelData result;
23752
23753   arg1 = jarg1;
23754   arg2 = (unsigned int)jarg2;
23755   arg3 = (unsigned int)jarg3;
23756   arg4 = (unsigned int)jarg4;
23757   arg5 = (Dali::Pixel::Format)jarg5;
23758   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23759   {
23760     try {
23761       auto pixelBuffer = new unsigned char[jarg2];
23762       memcpy( pixelBuffer, arg1, arg2);
23763       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23764     } catch (std::out_of_range& e) {
23765       {
23766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23767       };
23768     } catch (std::exception& e) {
23769       {
23770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23771       };
23772     } catch (Dali::DaliException e) {
23773       {
23774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23775       };
23776     } catch (...) {
23777       {
23778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23779       };
23780     }
23781   }
23782
23783   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23784
23785
23786   return jresult;
23787 }
23788
23789
23790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23791   void * jresult ;
23792   Dali::PixelData *result = 0 ;
23793
23794   {
23795     try {
23796       result = (Dali::PixelData *)new Dali::PixelData();
23797     } catch (std::out_of_range& e) {
23798       {
23799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23800       };
23801     } catch (std::exception& e) {
23802       {
23803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23804       };
23805     } catch (Dali::DaliException e) {
23806       {
23807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23808       };
23809     } catch (...) {
23810       {
23811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23812       };
23813     }
23814   }
23815
23816   jresult = (void *)result;
23817   return jresult;
23818 }
23819
23820
23821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23822   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23823
23824   arg1 = (Dali::PixelData *)jarg1;
23825   {
23826     try {
23827       delete arg1;
23828     } catch (std::out_of_range& e) {
23829       {
23830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23831       };
23832     } catch (std::exception& e) {
23833       {
23834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23835       };
23836     } catch (Dali::DaliException e) {
23837       {
23838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23839       };
23840     } catch (...) {
23841       {
23842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23843       };
23844     }
23845   }
23846
23847 }
23848
23849
23850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23851   void * jresult ;
23852   Dali::PixelData *arg1 = 0 ;
23853   Dali::PixelData *result = 0 ;
23854
23855   arg1 = (Dali::PixelData *)jarg1;
23856   if (!arg1) {
23857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23858     return 0;
23859   }
23860   {
23861     try {
23862       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23863     } catch (std::out_of_range& e) {
23864       {
23865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23866       };
23867     } catch (std::exception& e) {
23868       {
23869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23870       };
23871     } catch (Dali::DaliException e) {
23872       {
23873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23874       };
23875     } catch (...) {
23876       {
23877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23878       };
23879     }
23880   }
23881
23882   jresult = (void *)result;
23883   return jresult;
23884 }
23885
23886
23887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23888   void * jresult ;
23889   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23890   Dali::PixelData *arg2 = 0 ;
23891   Dali::PixelData *result = 0 ;
23892
23893   arg1 = (Dali::PixelData *)jarg1;
23894   arg2 = (Dali::PixelData *)jarg2;
23895   if (!arg2) {
23896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23897     return 0;
23898   }
23899   {
23900     try {
23901       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23902     } catch (std::out_of_range& e) {
23903       {
23904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23905       };
23906     } catch (std::exception& e) {
23907       {
23908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23909       };
23910     } catch (Dali::DaliException e) {
23911       {
23912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23913       };
23914     } catch (...) {
23915       {
23916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23917       };
23918     }
23919   }
23920
23921   jresult = (void *)result;
23922   return jresult;
23923 }
23924
23925
23926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23927   unsigned int jresult ;
23928   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23929   unsigned int result;
23930
23931   arg1 = (Dali::PixelData *)jarg1;
23932   {
23933     try {
23934       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23935     } catch (std::out_of_range& e) {
23936       {
23937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23938       };
23939     } catch (std::exception& e) {
23940       {
23941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23942       };
23943     } catch (Dali::DaliException e) {
23944       {
23945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23946       };
23947     } catch (...) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23950       };
23951     }
23952   }
23953
23954   jresult = result;
23955   return jresult;
23956 }
23957
23958
23959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23960   unsigned int jresult ;
23961   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23962   unsigned int result;
23963
23964   arg1 = (Dali::PixelData *)jarg1;
23965   {
23966     try {
23967       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23968     } catch (std::out_of_range& e) {
23969       {
23970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23971       };
23972     } catch (std::exception& e) {
23973       {
23974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23975       };
23976     } catch (Dali::DaliException e) {
23977       {
23978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23979       };
23980     } catch (...) {
23981       {
23982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23983       };
23984     }
23985   }
23986
23987   jresult = result;
23988   return jresult;
23989 }
23990
23991
23992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23993   int jresult ;
23994   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23995   Dali::Pixel::Format result;
23996
23997   arg1 = (Dali::PixelData *)jarg1;
23998   {
23999     try {
24000       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24001     } catch (std::out_of_range& e) {
24002       {
24003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24004       };
24005     } catch (std::exception& e) {
24006       {
24007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24008       };
24009     } catch (Dali::DaliException e) {
24010       {
24011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24012       };
24013     } catch (...) {
24014       {
24015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24016       };
24017     }
24018   }
24019
24020   jresult = (int)result;
24021   return jresult;
24022 }
24023
24024
24025 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24026   unsigned int jresult ;
24027   unsigned int result;
24028
24029   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24030   jresult = result;
24031   return jresult;
24032 }
24033
24034
24035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24036   unsigned int jresult ;
24037   unsigned int result;
24038
24039   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24040   jresult = result;
24041   return jresult;
24042 }
24043
24044
24045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24046   unsigned int jresult ;
24047   unsigned int result;
24048
24049   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24050   jresult = result;
24051   return jresult;
24052 }
24053
24054
24055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24056   unsigned int jresult ;
24057   unsigned int result;
24058
24059   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24060   jresult = result;
24061   return jresult;
24062 }
24063
24064
24065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24066   unsigned int jresult ;
24067   unsigned int result;
24068
24069   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24070   jresult = result;
24071   return jresult;
24072 }
24073
24074
24075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24076   unsigned int jresult ;
24077   unsigned int result;
24078
24079   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24080   jresult = result;
24081   return jresult;
24082 }
24083
24084
24085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24086   void * jresult ;
24087   Dali::TextureType::Type arg1 ;
24088   Dali::Pixel::Format arg2 ;
24089   unsigned int arg3 ;
24090   unsigned int arg4 ;
24091   Dali::Texture result;
24092
24093   arg1 = (Dali::TextureType::Type)jarg1;
24094   arg2 = (Dali::Pixel::Format)jarg2;
24095   arg3 = (unsigned int)jarg3;
24096   arg4 = (unsigned int)jarg4;
24097   {
24098     try {
24099       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24100     } catch (std::out_of_range& e) {
24101       {
24102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24103       };
24104     } catch (std::exception& e) {
24105       {
24106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24107       };
24108     } catch (Dali::DaliException e) {
24109       {
24110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24111       };
24112     } catch (...) {
24113       {
24114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24115       };
24116     }
24117   }
24118
24119   jresult = new Dali::Texture((const Dali::Texture &)result);
24120   return jresult;
24121 }
24122
24123
24124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24125   void * jresult ;
24126   NativeImageInterface *arg1 = 0 ;
24127   Dali::Texture result;
24128
24129   arg1 = (NativeImageInterface *)jarg1;
24130   if (!arg1) {
24131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24132     return 0;
24133   }
24134   {
24135     try {
24136       result = Dali::Texture::New(*arg1);
24137     } catch (std::out_of_range& e) {
24138       {
24139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24140       };
24141     } catch (std::exception& e) {
24142       {
24143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24144       };
24145     } catch (Dali::DaliException e) {
24146       {
24147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24148       };
24149     } catch (...) {
24150       {
24151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24152       };
24153     }
24154   }
24155
24156   jresult = new Dali::Texture((const Dali::Texture &)result);
24157   return jresult;
24158 }
24159
24160
24161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24162   void * jresult ;
24163   Dali::Texture *result = 0 ;
24164
24165   {
24166     try {
24167       result = (Dali::Texture *)new Dali::Texture();
24168     } catch (std::out_of_range& e) {
24169       {
24170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24171       };
24172     } catch (std::exception& e) {
24173       {
24174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24175       };
24176     } catch (Dali::DaliException e) {
24177       {
24178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24179       };
24180     } catch (...) {
24181       {
24182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24183       };
24184     }
24185   }
24186
24187   jresult = (void *)result;
24188   return jresult;
24189 }
24190
24191
24192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24193   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24194
24195   arg1 = (Dali::Texture *)jarg1;
24196   {
24197     try {
24198       delete arg1;
24199     } catch (std::out_of_range& e) {
24200       {
24201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24202       };
24203     } catch (std::exception& e) {
24204       {
24205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24206       };
24207     } catch (Dali::DaliException e) {
24208       {
24209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24210       };
24211     } catch (...) {
24212       {
24213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24214       };
24215     }
24216   }
24217
24218 }
24219
24220
24221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24222   void * jresult ;
24223   Dali::Texture *arg1 = 0 ;
24224   Dali::Texture *result = 0 ;
24225
24226   arg1 = (Dali::Texture *)jarg1;
24227   if (!arg1) {
24228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24229     return 0;
24230   }
24231   {
24232     try {
24233       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24234     } catch (std::out_of_range& e) {
24235       {
24236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24237       };
24238     } catch (std::exception& e) {
24239       {
24240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24241       };
24242     } catch (Dali::DaliException e) {
24243       {
24244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24245       };
24246     } catch (...) {
24247       {
24248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24249       };
24250     }
24251   }
24252
24253   jresult = (void *)result;
24254   return jresult;
24255 }
24256
24257
24258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24259   void * jresult ;
24260   Dali::BaseHandle arg1 ;
24261   Dali::BaseHandle *argp1 ;
24262   Dali::Texture result;
24263
24264   argp1 = (Dali::BaseHandle *)jarg1;
24265   if (!argp1) {
24266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24267     return 0;
24268   }
24269   arg1 = *argp1;
24270   {
24271     try {
24272       result = Dali::Texture::DownCast(arg1);
24273     } catch (std::out_of_range& e) {
24274       {
24275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24276       };
24277     } catch (std::exception& e) {
24278       {
24279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24280       };
24281     } catch (Dali::DaliException e) {
24282       {
24283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24284       };
24285     } catch (...) {
24286       {
24287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24288       };
24289     }
24290   }
24291
24292   jresult = new Dali::Texture((const Dali::Texture &)result);
24293   return jresult;
24294 }
24295
24296
24297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24298   void * jresult ;
24299   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24300   Dali::Texture *arg2 = 0 ;
24301   Dali::Texture *result = 0 ;
24302
24303   arg1 = (Dali::Texture *)jarg1;
24304   arg2 = (Dali::Texture *)jarg2;
24305   if (!arg2) {
24306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24307     return 0;
24308   }
24309   {
24310     try {
24311       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24312     } catch (std::out_of_range& e) {
24313       {
24314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24315       };
24316     } catch (std::exception& e) {
24317       {
24318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24319       };
24320     } catch (Dali::DaliException e) {
24321       {
24322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24323       };
24324     } catch (...) {
24325       {
24326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24327       };
24328     }
24329   }
24330
24331   jresult = (void *)result;
24332   return jresult;
24333 }
24334
24335
24336 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24337   unsigned int jresult ;
24338   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24339   Dali::PixelData arg2 ;
24340   Dali::PixelData *argp2 ;
24341   bool result;
24342
24343   arg1 = (Dali::Texture *)jarg1;
24344   argp2 = (Dali::PixelData *)jarg2;
24345   if (!argp2) {
24346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24347     return 0;
24348   }
24349   arg2 = *argp2;
24350   {
24351     try {
24352       result = (bool)(arg1)->Upload(arg2);
24353     } catch (std::out_of_range& e) {
24354       {
24355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24356       };
24357     } catch (std::exception& e) {
24358       {
24359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24360       };
24361     } catch (Dali::DaliException e) {
24362       {
24363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24364       };
24365     } catch (...) {
24366       {
24367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24368       };
24369     }
24370   }
24371
24372   jresult = result;
24373   return jresult;
24374 }
24375
24376
24377 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) {
24378   unsigned int jresult ;
24379   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24380   Dali::PixelData arg2 ;
24381   unsigned int arg3 ;
24382   unsigned int arg4 ;
24383   unsigned int arg5 ;
24384   unsigned int arg6 ;
24385   unsigned int arg7 ;
24386   unsigned int arg8 ;
24387   Dali::PixelData *argp2 ;
24388   bool result;
24389
24390   arg1 = (Dali::Texture *)jarg1;
24391   argp2 = (Dali::PixelData *)jarg2;
24392   if (!argp2) {
24393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24394     return 0;
24395   }
24396   arg2 = *argp2;
24397   arg3 = (unsigned int)jarg3;
24398   arg4 = (unsigned int)jarg4;
24399   arg5 = (unsigned int)jarg5;
24400   arg6 = (unsigned int)jarg6;
24401   arg7 = (unsigned int)jarg7;
24402   arg8 = (unsigned int)jarg8;
24403   {
24404     try {
24405       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24406     } catch (std::out_of_range& e) {
24407       {
24408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24409       };
24410     } catch (std::exception& e) {
24411       {
24412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24413       };
24414     } catch (Dali::DaliException e) {
24415       {
24416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24417       };
24418     } catch (...) {
24419       {
24420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24421       };
24422     }
24423   }
24424
24425   jresult = result;
24426   return jresult;
24427 }
24428
24429
24430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24431   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24432
24433   arg1 = (Dali::Texture *)jarg1;
24434   {
24435     try {
24436       (arg1)->GenerateMipmaps();
24437     } catch (std::out_of_range& e) {
24438       {
24439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24440       };
24441     } catch (std::exception& e) {
24442       {
24443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24444       };
24445     } catch (Dali::DaliException e) {
24446       {
24447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24448       };
24449     } catch (...) {
24450       {
24451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24452       };
24453     }
24454   }
24455
24456 }
24457
24458
24459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24460   unsigned int jresult ;
24461   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24462   unsigned int result;
24463
24464   arg1 = (Dali::Texture *)jarg1;
24465   {
24466     try {
24467       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24468     } catch (std::out_of_range& e) {
24469       {
24470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24471       };
24472     } catch (std::exception& e) {
24473       {
24474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24475       };
24476     } catch (Dali::DaliException e) {
24477       {
24478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24479       };
24480     } catch (...) {
24481       {
24482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24483       };
24484     }
24485   }
24486
24487   jresult = result;
24488   return jresult;
24489 }
24490
24491
24492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24493   unsigned int jresult ;
24494   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24495   unsigned int result;
24496
24497   arg1 = (Dali::Texture *)jarg1;
24498   {
24499     try {
24500       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24501     } catch (std::out_of_range& e) {
24502       {
24503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24504       };
24505     } catch (std::exception& e) {
24506       {
24507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24508       };
24509     } catch (Dali::DaliException e) {
24510       {
24511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24512       };
24513     } catch (...) {
24514       {
24515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24516       };
24517     }
24518   }
24519
24520   jresult = result;
24521   return jresult;
24522 }
24523
24524
24525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24526   void * jresult ;
24527   Dali::Sampler result;
24528
24529   {
24530     try {
24531       result = Dali::Sampler::New();
24532     } catch (std::out_of_range& e) {
24533       {
24534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (std::exception& e) {
24537       {
24538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24539       };
24540     } catch (Dali::DaliException e) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24543       };
24544     } catch (...) {
24545       {
24546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24547       };
24548     }
24549   }
24550
24551   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24552   return jresult;
24553 }
24554
24555
24556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24557   void * jresult ;
24558   Dali::Sampler *result = 0 ;
24559
24560   {
24561     try {
24562       result = (Dali::Sampler *)new Dali::Sampler();
24563     } catch (std::out_of_range& e) {
24564       {
24565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24566       };
24567     } catch (std::exception& e) {
24568       {
24569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24570       };
24571     } catch (Dali::DaliException e) {
24572       {
24573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24574       };
24575     } catch (...) {
24576       {
24577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24578       };
24579     }
24580   }
24581
24582   jresult = (void *)result;
24583   return jresult;
24584 }
24585
24586
24587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24588   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24589
24590   arg1 = (Dali::Sampler *)jarg1;
24591   {
24592     try {
24593       delete arg1;
24594     } catch (std::out_of_range& e) {
24595       {
24596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24597       };
24598     } catch (std::exception& e) {
24599       {
24600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24601       };
24602     } catch (Dali::DaliException e) {
24603       {
24604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24605       };
24606     } catch (...) {
24607       {
24608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24609       };
24610     }
24611   }
24612
24613 }
24614
24615
24616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24617   void * jresult ;
24618   Dali::Sampler *arg1 = 0 ;
24619   Dali::Sampler *result = 0 ;
24620
24621   arg1 = (Dali::Sampler *)jarg1;
24622   if (!arg1) {
24623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24624     return 0;
24625   }
24626   {
24627     try {
24628       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24629     } catch (std::out_of_range& e) {
24630       {
24631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24632       };
24633     } catch (std::exception& e) {
24634       {
24635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24636       };
24637     } catch (Dali::DaliException e) {
24638       {
24639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24640       };
24641     } catch (...) {
24642       {
24643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24644       };
24645     }
24646   }
24647
24648   jresult = (void *)result;
24649   return jresult;
24650 }
24651
24652
24653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24654   void * jresult ;
24655   Dali::BaseHandle arg1 ;
24656   Dali::BaseHandle *argp1 ;
24657   Dali::Sampler result;
24658
24659   argp1 = (Dali::BaseHandle *)jarg1;
24660   if (!argp1) {
24661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24662     return 0;
24663   }
24664   arg1 = *argp1;
24665   {
24666     try {
24667       result = Dali::Sampler::DownCast(arg1);
24668     } catch (std::out_of_range& e) {
24669       {
24670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24671       };
24672     } catch (std::exception& e) {
24673       {
24674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24675       };
24676     } catch (Dali::DaliException e) {
24677       {
24678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24679       };
24680     } catch (...) {
24681       {
24682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24683       };
24684     }
24685   }
24686
24687   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24688   return jresult;
24689 }
24690
24691
24692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24693   void * jresult ;
24694   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24695   Dali::Sampler *arg2 = 0 ;
24696   Dali::Sampler *result = 0 ;
24697
24698   arg1 = (Dali::Sampler *)jarg1;
24699   arg2 = (Dali::Sampler *)jarg2;
24700   if (!arg2) {
24701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24702     return 0;
24703   }
24704   {
24705     try {
24706       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24707     } catch (std::out_of_range& e) {
24708       {
24709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24710       };
24711     } catch (std::exception& e) {
24712       {
24713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24714       };
24715     } catch (Dali::DaliException e) {
24716       {
24717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24718       };
24719     } catch (...) {
24720       {
24721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24722       };
24723     }
24724   }
24725
24726   jresult = (void *)result;
24727   return jresult;
24728 }
24729
24730
24731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24732   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24733   Dali::FilterMode::Type arg2 ;
24734   Dali::FilterMode::Type arg3 ;
24735
24736   arg1 = (Dali::Sampler *)jarg1;
24737   arg2 = (Dali::FilterMode::Type)jarg2;
24738   arg3 = (Dali::FilterMode::Type)jarg3;
24739   {
24740     try {
24741       (arg1)->SetFilterMode(arg2,arg3);
24742     } catch (std::out_of_range& e) {
24743       {
24744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24745       };
24746     } catch (std::exception& e) {
24747       {
24748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24749       };
24750     } catch (Dali::DaliException e) {
24751       {
24752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24753       };
24754     } catch (...) {
24755       {
24756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24757       };
24758     }
24759   }
24760
24761 }
24762
24763
24764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24765   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24766   Dali::WrapMode::Type arg2 ;
24767   Dali::WrapMode::Type arg3 ;
24768
24769   arg1 = (Dali::Sampler *)jarg1;
24770   arg2 = (Dali::WrapMode::Type)jarg2;
24771   arg3 = (Dali::WrapMode::Type)jarg3;
24772   {
24773     try {
24774       (arg1)->SetWrapMode(arg2,arg3);
24775     } catch (std::out_of_range& e) {
24776       {
24777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24778       };
24779     } catch (std::exception& e) {
24780       {
24781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24782       };
24783     } catch (Dali::DaliException e) {
24784       {
24785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24786       };
24787     } catch (...) {
24788       {
24789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24790       };
24791     }
24792   }
24793
24794 }
24795
24796
24797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24798   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24799   Dali::WrapMode::Type arg2 ;
24800   Dali::WrapMode::Type arg3 ;
24801   Dali::WrapMode::Type arg4 ;
24802
24803   arg1 = (Dali::Sampler *)jarg1;
24804   arg2 = (Dali::WrapMode::Type)jarg2;
24805   arg3 = (Dali::WrapMode::Type)jarg3;
24806   arg4 = (Dali::WrapMode::Type)jarg4;
24807   {
24808     try {
24809       (arg1)->SetWrapMode(arg2,arg3,arg4);
24810     } catch (std::out_of_range& e) {
24811       {
24812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24813       };
24814     } catch (std::exception& e) {
24815       {
24816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24817       };
24818     } catch (Dali::DaliException e) {
24819       {
24820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24821       };
24822     } catch (...) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24825       };
24826     }
24827   }
24828
24829 }
24830
24831
24832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24833   void * jresult ;
24834   Dali::TextureSet result;
24835
24836   {
24837     try {
24838       result = Dali::TextureSet::New();
24839     } catch (std::out_of_range& e) {
24840       {
24841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24842       };
24843     } catch (std::exception& e) {
24844       {
24845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24846       };
24847     } catch (Dali::DaliException e) {
24848       {
24849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24850       };
24851     } catch (...) {
24852       {
24853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24854       };
24855     }
24856   }
24857
24858   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24859   return jresult;
24860 }
24861
24862
24863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24864   void * jresult ;
24865   Dali::TextureSet *result = 0 ;
24866
24867   {
24868     try {
24869       result = (Dali::TextureSet *)new Dali::TextureSet();
24870     } catch (std::out_of_range& e) {
24871       {
24872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24873       };
24874     } catch (std::exception& e) {
24875       {
24876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24877       };
24878     } catch (Dali::DaliException e) {
24879       {
24880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24881       };
24882     } catch (...) {
24883       {
24884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24885       };
24886     }
24887   }
24888
24889   jresult = (void *)result;
24890   return jresult;
24891 }
24892
24893
24894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24895   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24896
24897   arg1 = (Dali::TextureSet *)jarg1;
24898   {
24899     try {
24900       delete arg1;
24901     } catch (std::out_of_range& e) {
24902       {
24903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24904       };
24905     } catch (std::exception& e) {
24906       {
24907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24908       };
24909     } catch (Dali::DaliException e) {
24910       {
24911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24912       };
24913     } catch (...) {
24914       {
24915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24916       };
24917     }
24918   }
24919
24920 }
24921
24922
24923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24924   void * jresult ;
24925   Dali::TextureSet *arg1 = 0 ;
24926   Dali::TextureSet *result = 0 ;
24927
24928   arg1 = (Dali::TextureSet *)jarg1;
24929   if (!arg1) {
24930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24931     return 0;
24932   }
24933   {
24934     try {
24935       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24936     } catch (std::out_of_range& e) {
24937       {
24938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24939       };
24940     } catch (std::exception& e) {
24941       {
24942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24943       };
24944     } catch (Dali::DaliException e) {
24945       {
24946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24947       };
24948     } catch (...) {
24949       {
24950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24951       };
24952     }
24953   }
24954
24955   jresult = (void *)result;
24956   return jresult;
24957 }
24958
24959
24960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24961   void * jresult ;
24962   Dali::BaseHandle arg1 ;
24963   Dali::BaseHandle *argp1 ;
24964   Dali::TextureSet result;
24965
24966   argp1 = (Dali::BaseHandle *)jarg1;
24967   if (!argp1) {
24968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24969     return 0;
24970   }
24971   arg1 = *argp1;
24972   {
24973     try {
24974       result = Dali::TextureSet::DownCast(arg1);
24975     } catch (std::out_of_range& e) {
24976       {
24977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24978       };
24979     } catch (std::exception& e) {
24980       {
24981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24982       };
24983     } catch (Dali::DaliException e) {
24984       {
24985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24986       };
24987     } catch (...) {
24988       {
24989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24990       };
24991     }
24992   }
24993
24994   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24995   return jresult;
24996 }
24997
24998
24999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25000   void * jresult ;
25001   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25002   Dali::TextureSet *arg2 = 0 ;
25003   Dali::TextureSet *result = 0 ;
25004
25005   arg1 = (Dali::TextureSet *)jarg1;
25006   arg2 = (Dali::TextureSet *)jarg2;
25007   if (!arg2) {
25008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25009     return 0;
25010   }
25011   {
25012     try {
25013       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25014     } catch (std::out_of_range& e) {
25015       {
25016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25017       };
25018     } catch (std::exception& e) {
25019       {
25020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25021       };
25022     } catch (Dali::DaliException e) {
25023       {
25024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25025       };
25026     } catch (...) {
25027       {
25028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25029       };
25030     }
25031   }
25032
25033   jresult = (void *)result;
25034   return jresult;
25035 }
25036
25037
25038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25039   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25040   size_t arg2 ;
25041   Dali::Texture arg3 ;
25042   Dali::Texture *argp3 ;
25043
25044   arg1 = (Dali::TextureSet *)jarg1;
25045   arg2 = (size_t)jarg2;
25046   argp3 = (Dali::Texture *)jarg3;
25047   if (!argp3) {
25048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25049     return ;
25050   }
25051   arg3 = *argp3;
25052   {
25053     try {
25054       (arg1)->SetTexture(arg2,arg3);
25055     } catch (std::out_of_range& e) {
25056       {
25057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25058       };
25059     } catch (std::exception& e) {
25060       {
25061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25062       };
25063     } catch (Dali::DaliException e) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25066       };
25067     } catch (...) {
25068       {
25069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25070       };
25071     }
25072   }
25073
25074 }
25075
25076
25077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25078   void * jresult ;
25079   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25080   size_t arg2 ;
25081   Dali::Texture result;
25082
25083   arg1 = (Dali::TextureSet *)jarg1;
25084   arg2 = (size_t)jarg2;
25085   {
25086     try {
25087       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25088     } catch (std::out_of_range& e) {
25089       {
25090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25091       };
25092     } catch (std::exception& e) {
25093       {
25094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25095       };
25096     } catch (Dali::DaliException e) {
25097       {
25098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25099       };
25100     } catch (...) {
25101       {
25102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25103       };
25104     }
25105   }
25106
25107   jresult = new Dali::Texture((const Dali::Texture &)result);
25108   return jresult;
25109 }
25110
25111
25112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25113   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25114   size_t arg2 ;
25115   Dali::Sampler arg3 ;
25116   Dali::Sampler *argp3 ;
25117
25118   arg1 = (Dali::TextureSet *)jarg1;
25119   arg2 = (size_t)jarg2;
25120   argp3 = (Dali::Sampler *)jarg3;
25121   if (!argp3) {
25122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25123     return ;
25124   }
25125   arg3 = *argp3;
25126   {
25127     try {
25128       (arg1)->SetSampler(arg2,arg3);
25129     } catch (std::out_of_range& e) {
25130       {
25131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25132       };
25133     } catch (std::exception& e) {
25134       {
25135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25136       };
25137     } catch (Dali::DaliException e) {
25138       {
25139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25140       };
25141     } catch (...) {
25142       {
25143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25144       };
25145     }
25146   }
25147
25148 }
25149
25150
25151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25152   void * jresult ;
25153   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25154   size_t arg2 ;
25155   Dali::Sampler result;
25156
25157   arg1 = (Dali::TextureSet *)jarg1;
25158   arg2 = (size_t)jarg2;
25159   {
25160     try {
25161       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25162     } catch (std::out_of_range& e) {
25163       {
25164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25165       };
25166     } catch (std::exception& e) {
25167       {
25168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25169       };
25170     } catch (Dali::DaliException e) {
25171       {
25172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25173       };
25174     } catch (...) {
25175       {
25176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25177       };
25178     }
25179   }
25180
25181   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25182   return jresult;
25183 }
25184
25185
25186 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25187   unsigned long jresult ;
25188   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25189   size_t result;
25190
25191   arg1 = (Dali::TextureSet *)jarg1;
25192   {
25193     try {
25194       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25195     } catch (std::out_of_range& e) {
25196       {
25197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25198       };
25199     } catch (std::exception& e) {
25200       {
25201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25202       };
25203     } catch (Dali::DaliException e) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25206       };
25207     } catch (...) {
25208       {
25209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25210       };
25211     }
25212   }
25213
25214   jresult = (unsigned long)result;
25215   return jresult;
25216 }
25217
25218
25219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25220   void * jresult ;
25221   Dali::Property::Map *arg1 = 0 ;
25222   Dali::PropertyBuffer result;
25223
25224   arg1 = (Dali::Property::Map *)jarg1;
25225   if (!arg1) {
25226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25227     return 0;
25228   }
25229   {
25230     try {
25231       result = Dali::PropertyBuffer::New(*arg1);
25232     } catch (std::out_of_range& e) {
25233       {
25234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25235       };
25236     } catch (std::exception& e) {
25237       {
25238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25239       };
25240     } catch (Dali::DaliException e) {
25241       {
25242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25243       };
25244     } catch (...) {
25245       {
25246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25247       };
25248     }
25249   }
25250
25251   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25252   return jresult;
25253 }
25254
25255
25256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25257   void * jresult ;
25258   Dali::PropertyBuffer *result = 0 ;
25259
25260   {
25261     try {
25262       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25263     } catch (std::out_of_range& e) {
25264       {
25265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25266       };
25267     } catch (std::exception& e) {
25268       {
25269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25270       };
25271     } catch (Dali::DaliException e) {
25272       {
25273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25274       };
25275     } catch (...) {
25276       {
25277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25278       };
25279     }
25280   }
25281
25282   jresult = (void *)result;
25283   return jresult;
25284 }
25285
25286
25287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25288   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25289
25290   arg1 = (Dali::PropertyBuffer *)jarg1;
25291   {
25292     try {
25293       delete arg1;
25294     } catch (std::out_of_range& e) {
25295       {
25296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25297       };
25298     } catch (std::exception& e) {
25299       {
25300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25301       };
25302     } catch (Dali::DaliException e) {
25303       {
25304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25305       };
25306     } catch (...) {
25307       {
25308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25309       };
25310     }
25311   }
25312
25313 }
25314
25315
25316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25317   void * jresult ;
25318   Dali::PropertyBuffer *arg1 = 0 ;
25319   Dali::PropertyBuffer *result = 0 ;
25320
25321   arg1 = (Dali::PropertyBuffer *)jarg1;
25322   if (!arg1) {
25323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25324     return 0;
25325   }
25326   {
25327     try {
25328       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25329     } catch (std::out_of_range& e) {
25330       {
25331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25332       };
25333     } catch (std::exception& e) {
25334       {
25335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25336       };
25337     } catch (Dali::DaliException e) {
25338       {
25339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25340       };
25341     } catch (...) {
25342       {
25343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25344       };
25345     }
25346   }
25347
25348   jresult = (void *)result;
25349   return jresult;
25350 }
25351
25352
25353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25354   void * jresult ;
25355   Dali::BaseHandle arg1 ;
25356   Dali::BaseHandle *argp1 ;
25357   Dali::PropertyBuffer result;
25358
25359   argp1 = (Dali::BaseHandle *)jarg1;
25360   if (!argp1) {
25361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25362     return 0;
25363   }
25364   arg1 = *argp1;
25365   {
25366     try {
25367       result = Dali::PropertyBuffer::DownCast(arg1);
25368     } catch (std::out_of_range& e) {
25369       {
25370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25371       };
25372     } catch (std::exception& e) {
25373       {
25374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25375       };
25376     } catch (Dali::DaliException e) {
25377       {
25378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25379       };
25380     } catch (...) {
25381       {
25382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25383       };
25384     }
25385   }
25386
25387   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25388   return jresult;
25389 }
25390
25391
25392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25393   void * jresult ;
25394   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25395   Dali::PropertyBuffer *arg2 = 0 ;
25396   Dali::PropertyBuffer *result = 0 ;
25397
25398   arg1 = (Dali::PropertyBuffer *)jarg1;
25399   arg2 = (Dali::PropertyBuffer *)jarg2;
25400   if (!arg2) {
25401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25402     return 0;
25403   }
25404   {
25405     try {
25406       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25407     } catch (std::out_of_range& e) {
25408       {
25409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25410       };
25411     } catch (std::exception& e) {
25412       {
25413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25414       };
25415     } catch (Dali::DaliException e) {
25416       {
25417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25418       };
25419     } catch (...) {
25420       {
25421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25422       };
25423     }
25424   }
25425
25426   jresult = (void *)result;
25427   return jresult;
25428 }
25429
25430
25431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25432   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25433   void *arg2 = (void *) 0 ;
25434   std::size_t arg3 ;
25435
25436   arg1 = (Dali::PropertyBuffer *)jarg1;
25437   arg2 = jarg2;
25438   arg3 = (std::size_t)jarg3;
25439   {
25440     try {
25441       (arg1)->SetData((void const *)arg2,arg3);
25442     } catch (std::out_of_range& e) {
25443       {
25444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25445       };
25446     } catch (std::exception& e) {
25447       {
25448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25449       };
25450     } catch (Dali::DaliException e) {
25451       {
25452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25453       };
25454     } catch (...) {
25455       {
25456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25457       };
25458     }
25459   }
25460
25461 }
25462
25463
25464 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25465   unsigned long jresult ;
25466   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25467   std::size_t result;
25468
25469   arg1 = (Dali::PropertyBuffer *)jarg1;
25470   {
25471     try {
25472       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25473     } catch (std::out_of_range& e) {
25474       {
25475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25476       };
25477     } catch (std::exception& e) {
25478       {
25479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25480       };
25481     } catch (Dali::DaliException e) {
25482       {
25483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25484       };
25485     } catch (...) {
25486       {
25487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25488       };
25489     }
25490   }
25491
25492   jresult = (unsigned long)result;
25493   return jresult;
25494 }
25495
25496
25497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25498   void * jresult ;
25499   Dali::Geometry result;
25500
25501   {
25502     try {
25503       result = Dali::Geometry::New();
25504     } catch (std::out_of_range& e) {
25505       {
25506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25507       };
25508     } catch (std::exception& e) {
25509       {
25510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25511       };
25512     } catch (Dali::DaliException e) {
25513       {
25514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25515       };
25516     } catch (...) {
25517       {
25518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25519       };
25520     }
25521   }
25522
25523   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25524   return jresult;
25525 }
25526
25527
25528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25529   void * jresult ;
25530   Dali::Geometry *result = 0 ;
25531
25532   {
25533     try {
25534       result = (Dali::Geometry *)new Dali::Geometry();
25535     } catch (std::out_of_range& e) {
25536       {
25537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25538       };
25539     } catch (std::exception& e) {
25540       {
25541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25542       };
25543     } catch (Dali::DaliException e) {
25544       {
25545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25546       };
25547     } catch (...) {
25548       {
25549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25550       };
25551     }
25552   }
25553
25554   jresult = (void *)result;
25555   return jresult;
25556 }
25557
25558
25559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25560   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25561
25562   arg1 = (Dali::Geometry *)jarg1;
25563   {
25564     try {
25565       delete arg1;
25566     } catch (std::out_of_range& e) {
25567       {
25568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25569       };
25570     } catch (std::exception& e) {
25571       {
25572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25573       };
25574     } catch (Dali::DaliException e) {
25575       {
25576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25577       };
25578     } catch (...) {
25579       {
25580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25581       };
25582     }
25583   }
25584
25585 }
25586
25587
25588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25589   void * jresult ;
25590   Dali::Geometry *arg1 = 0 ;
25591   Dali::Geometry *result = 0 ;
25592
25593   arg1 = (Dali::Geometry *)jarg1;
25594   if (!arg1) {
25595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25596     return 0;
25597   }
25598   {
25599     try {
25600       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25601     } catch (std::out_of_range& e) {
25602       {
25603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25604       };
25605     } catch (std::exception& e) {
25606       {
25607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25608       };
25609     } catch (Dali::DaliException e) {
25610       {
25611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25612       };
25613     } catch (...) {
25614       {
25615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25616       };
25617     }
25618   }
25619
25620   jresult = (void *)result;
25621   return jresult;
25622 }
25623
25624
25625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25626   void * jresult ;
25627   Dali::BaseHandle arg1 ;
25628   Dali::BaseHandle *argp1 ;
25629   Dali::Geometry result;
25630
25631   argp1 = (Dali::BaseHandle *)jarg1;
25632   if (!argp1) {
25633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25634     return 0;
25635   }
25636   arg1 = *argp1;
25637   {
25638     try {
25639       result = Dali::Geometry::DownCast(arg1);
25640     } catch (std::out_of_range& e) {
25641       {
25642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25643       };
25644     } catch (std::exception& e) {
25645       {
25646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25647       };
25648     } catch (Dali::DaliException e) {
25649       {
25650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25651       };
25652     } catch (...) {
25653       {
25654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25655       };
25656     }
25657   }
25658
25659   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25660   return jresult;
25661 }
25662
25663
25664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25665   void * jresult ;
25666   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25667   Dali::Geometry *arg2 = 0 ;
25668   Dali::Geometry *result = 0 ;
25669
25670   arg1 = (Dali::Geometry *)jarg1;
25671   arg2 = (Dali::Geometry *)jarg2;
25672   if (!arg2) {
25673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25674     return 0;
25675   }
25676   {
25677     try {
25678       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25679     } catch (std::out_of_range& e) {
25680       {
25681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25682       };
25683     } catch (std::exception& e) {
25684       {
25685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25686       };
25687     } catch (Dali::DaliException e) {
25688       {
25689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25690       };
25691     } catch (...) {
25692       {
25693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25694       };
25695     }
25696   }
25697
25698   jresult = (void *)result;
25699   return jresult;
25700 }
25701
25702
25703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25704   unsigned long jresult ;
25705   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25706   Dali::PropertyBuffer *arg2 = 0 ;
25707   std::size_t result;
25708
25709   arg1 = (Dali::Geometry *)jarg1;
25710   arg2 = (Dali::PropertyBuffer *)jarg2;
25711   if (!arg2) {
25712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25713     return 0;
25714   }
25715   {
25716     try {
25717       result = (arg1)->AddVertexBuffer(*arg2);
25718     } catch (std::out_of_range& e) {
25719       {
25720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25721       };
25722     } catch (std::exception& e) {
25723       {
25724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25725       };
25726     } catch (Dali::DaliException e) {
25727       {
25728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25729       };
25730     } catch (...) {
25731       {
25732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25733       };
25734     }
25735   }
25736
25737   jresult = (unsigned long)result;
25738   return jresult;
25739 }
25740
25741
25742 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25743   unsigned long jresult ;
25744   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25745   std::size_t result;
25746
25747   arg1 = (Dali::Geometry *)jarg1;
25748   {
25749     try {
25750       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25751     } catch (std::out_of_range& e) {
25752       {
25753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25754       };
25755     } catch (std::exception& e) {
25756       {
25757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25758       };
25759     } catch (Dali::DaliException e) {
25760       {
25761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25762       };
25763     } catch (...) {
25764       {
25765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25766       };
25767     }
25768   }
25769
25770   jresult = (unsigned long)result;
25771   return jresult;
25772 }
25773
25774
25775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25776   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25777   std::size_t arg2 ;
25778
25779   arg1 = (Dali::Geometry *)jarg1;
25780   arg2 = (std::size_t)jarg2;
25781   {
25782     try {
25783       (arg1)->RemoveVertexBuffer(arg2);
25784     } catch (std::out_of_range& e) {
25785       {
25786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25787       };
25788     } catch (std::exception& e) {
25789       {
25790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25791       };
25792     } catch (Dali::DaliException e) {
25793       {
25794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25795       };
25796     } catch (...) {
25797       {
25798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25799       };
25800     }
25801   }
25802
25803 }
25804
25805
25806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25807   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25808   unsigned short *arg2 = (unsigned short *) 0 ;
25809   size_t arg3 ;
25810
25811   arg1 = (Dali::Geometry *)jarg1;
25812   arg2 = jarg2;
25813   arg3 = (size_t)jarg3;
25814   {
25815     try {
25816       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25817     } catch (std::out_of_range& e) {
25818       {
25819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25820       };
25821     } catch (std::exception& e) {
25822       {
25823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25824       };
25825     } catch (Dali::DaliException e) {
25826       {
25827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25828       };
25829     } catch (...) {
25830       {
25831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25832       };
25833     }
25834   }
25835
25836
25837
25838 }
25839
25840
25841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25842   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25843   Dali::Geometry::Type arg2 ;
25844
25845   arg1 = (Dali::Geometry *)jarg1;
25846   arg2 = (Dali::Geometry::Type)jarg2;
25847   {
25848     try {
25849       (arg1)->SetType(arg2);
25850     } catch (std::out_of_range& e) {
25851       {
25852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25853       };
25854     } catch (std::exception& e) {
25855       {
25856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25857       };
25858     } catch (Dali::DaliException e) {
25859       {
25860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25861       };
25862     } catch (...) {
25863       {
25864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25865       };
25866     }
25867   }
25868
25869 }
25870
25871
25872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25873   int jresult ;
25874   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25875   Dali::Geometry::Type result;
25876
25877   arg1 = (Dali::Geometry *)jarg1;
25878   {
25879     try {
25880       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25881     } catch (std::out_of_range& e) {
25882       {
25883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25884       };
25885     } catch (std::exception& e) {
25886       {
25887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25888       };
25889     } catch (Dali::DaliException e) {
25890       {
25891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25892       };
25893     } catch (...) {
25894       {
25895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25896       };
25897     }
25898   }
25899
25900   jresult = (int)result;
25901   return jresult;
25902 }
25903
25904
25905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25906   void * jresult ;
25907   Dali::Shader::Hint *result = 0 ;
25908
25909   {
25910     try {
25911       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25912     } catch (std::out_of_range& e) {
25913       {
25914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25915       };
25916     } catch (std::exception& e) {
25917       {
25918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25919       };
25920     } catch (Dali::DaliException e) {
25921       {
25922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25923       };
25924     } catch (...) {
25925       {
25926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25927       };
25928     }
25929   }
25930
25931   jresult = (void *)result;
25932   return jresult;
25933 }
25934
25935
25936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25937   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25938
25939   arg1 = (Dali::Shader::Hint *)jarg1;
25940   {
25941     try {
25942       delete arg1;
25943     } catch (std::out_of_range& e) {
25944       {
25945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25946       };
25947     } catch (std::exception& e) {
25948       {
25949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25950       };
25951     } catch (Dali::DaliException e) {
25952       {
25953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25954       };
25955     } catch (...) {
25956       {
25957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25958       };
25959     }
25960   }
25961
25962 }
25963
25964
25965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25966   int jresult ;
25967   int result;
25968
25969   result = (int)Dali::Shader::Property::PROGRAM;
25970   jresult = (int)result;
25971   return jresult;
25972 }
25973
25974
25975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25976   void * jresult ;
25977   Dali::Shader::Property *result = 0 ;
25978
25979   {
25980     try {
25981       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25982     } catch (std::out_of_range& e) {
25983       {
25984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25985       };
25986     } catch (std::exception& e) {
25987       {
25988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25989       };
25990     } catch (Dali::DaliException e) {
25991       {
25992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25993       };
25994     } catch (...) {
25995       {
25996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25997       };
25998     }
25999   }
26000
26001   jresult = (void *)result;
26002   return jresult;
26003 }
26004
26005
26006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26007   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26008
26009   arg1 = (Dali::Shader::Property *)jarg1;
26010   {
26011     try {
26012       delete arg1;
26013     } catch (std::out_of_range& e) {
26014       {
26015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26016       };
26017     } catch (std::exception& e) {
26018       {
26019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26020       };
26021     } catch (Dali::DaliException e) {
26022       {
26023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26024       };
26025     } catch (...) {
26026       {
26027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26028       };
26029     }
26030   }
26031
26032 }
26033
26034
26035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26036   void * jresult ;
26037   std::string *arg1 = 0 ;
26038   std::string *arg2 = 0 ;
26039   Dali::Shader::Hint::Value arg3 ;
26040   Dali::Shader result;
26041
26042   if (!jarg1) {
26043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26044     return 0;
26045   }
26046   std::string arg1_str(jarg1);
26047   arg1 = &arg1_str;
26048   if (!jarg2) {
26049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26050     return 0;
26051   }
26052   std::string arg2_str(jarg2);
26053   arg2 = &arg2_str;
26054   arg3 = (Dali::Shader::Hint::Value)jarg3;
26055   {
26056     try {
26057       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26058     } catch (std::out_of_range& e) {
26059       {
26060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26061       };
26062     } catch (std::exception& e) {
26063       {
26064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26065       };
26066     } catch (Dali::DaliException e) {
26067       {
26068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26069       };
26070     } catch (...) {
26071       {
26072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26073       };
26074     }
26075   }
26076
26077   jresult = new Dali::Shader((const Dali::Shader &)result);
26078
26079   //argout typemap for const std::string&
26080
26081
26082   //argout typemap for const std::string&
26083
26084   return jresult;
26085 }
26086
26087
26088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26089   void * jresult ;
26090   std::string *arg1 = 0 ;
26091   std::string *arg2 = 0 ;
26092   Dali::Shader result;
26093
26094   if (!jarg1) {
26095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26096     return 0;
26097   }
26098   std::string arg1_str(jarg1);
26099   arg1 = &arg1_str;
26100   if (!jarg2) {
26101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26102     return 0;
26103   }
26104   std::string arg2_str(jarg2);
26105   arg2 = &arg2_str;
26106   {
26107     try {
26108       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26109     } catch (std::out_of_range& e) {
26110       {
26111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26112       };
26113     } catch (std::exception& e) {
26114       {
26115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26116       };
26117     } catch (Dali::DaliException e) {
26118       {
26119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26120       };
26121     } catch (...) {
26122       {
26123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26124       };
26125     }
26126   }
26127
26128   jresult = new Dali::Shader((const Dali::Shader &)result);
26129
26130   //argout typemap for const std::string&
26131
26132
26133   //argout typemap for const std::string&
26134
26135   return jresult;
26136 }
26137
26138
26139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26140   void * jresult ;
26141   Dali::Shader *result = 0 ;
26142
26143   {
26144     try {
26145       result = (Dali::Shader *)new Dali::Shader();
26146     } catch (std::out_of_range& e) {
26147       {
26148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26149       };
26150     } catch (std::exception& e) {
26151       {
26152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26153       };
26154     } catch (Dali::DaliException e) {
26155       {
26156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26157       };
26158     } catch (...) {
26159       {
26160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26161       };
26162     }
26163   }
26164
26165   jresult = (void *)result;
26166   return jresult;
26167 }
26168
26169
26170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26171   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26172
26173   arg1 = (Dali::Shader *)jarg1;
26174   {
26175     try {
26176       delete arg1;
26177     } catch (std::out_of_range& e) {
26178       {
26179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26180       };
26181     } catch (std::exception& e) {
26182       {
26183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26184       };
26185     } catch (Dali::DaliException e) {
26186       {
26187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26188       };
26189     } catch (...) {
26190       {
26191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26192       };
26193     }
26194   }
26195
26196 }
26197
26198
26199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26200   void * jresult ;
26201   Dali::Shader *arg1 = 0 ;
26202   Dali::Shader *result = 0 ;
26203
26204   arg1 = (Dali::Shader *)jarg1;
26205   if (!arg1) {
26206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26207     return 0;
26208   }
26209   {
26210     try {
26211       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26212     } catch (std::out_of_range& e) {
26213       {
26214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26215       };
26216     } catch (std::exception& e) {
26217       {
26218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26219       };
26220     } catch (Dali::DaliException e) {
26221       {
26222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26223       };
26224     } catch (...) {
26225       {
26226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26227       };
26228     }
26229   }
26230
26231   jresult = (void *)result;
26232   return jresult;
26233 }
26234
26235
26236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26237   void * jresult ;
26238   Dali::BaseHandle arg1 ;
26239   Dali::BaseHandle *argp1 ;
26240   Dali::Shader result;
26241
26242   argp1 = (Dali::BaseHandle *)jarg1;
26243   if (!argp1) {
26244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26245     return 0;
26246   }
26247   arg1 = *argp1;
26248   {
26249     try {
26250       result = Dali::Shader::DownCast(arg1);
26251     } catch (std::out_of_range& e) {
26252       {
26253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26254       };
26255     } catch (std::exception& e) {
26256       {
26257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26258       };
26259     } catch (Dali::DaliException e) {
26260       {
26261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26262       };
26263     } catch (...) {
26264       {
26265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26266       };
26267     }
26268   }
26269
26270   jresult = new Dali::Shader((const Dali::Shader &)result);
26271   return jresult;
26272 }
26273
26274
26275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26276   void * jresult ;
26277   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26278   Dali::Shader *arg2 = 0 ;
26279   Dali::Shader *result = 0 ;
26280
26281   arg1 = (Dali::Shader *)jarg1;
26282   arg2 = (Dali::Shader *)jarg2;
26283   if (!arg2) {
26284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26285     return 0;
26286   }
26287   {
26288     try {
26289       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26290     } catch (std::out_of_range& e) {
26291       {
26292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26293       };
26294     } catch (std::exception& e) {
26295       {
26296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26297       };
26298     } catch (Dali::DaliException e) {
26299       {
26300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26301       };
26302     } catch (...) {
26303       {
26304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26305       };
26306     }
26307   }
26308
26309   jresult = (void *)result;
26310   return jresult;
26311 }
26312
26313
26314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26315   int jresult ;
26316   int result;
26317
26318   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26319   jresult = (int)result;
26320   return jresult;
26321 }
26322
26323
26324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26325   int jresult ;
26326   int result;
26327
26328   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26329   jresult = (int)result;
26330   return jresult;
26331 }
26332
26333
26334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26335   int jresult ;
26336   int result;
26337
26338   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26339   jresult = (int)result;
26340   return jresult;
26341 }
26342
26343
26344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26345   int jresult ;
26346   int result;
26347
26348   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26349   jresult = (int)result;
26350   return jresult;
26351 }
26352
26353
26354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26355   int jresult ;
26356   int result;
26357
26358   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26359   jresult = (int)result;
26360   return jresult;
26361 }
26362
26363
26364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26365   int jresult ;
26366   int result;
26367
26368   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26369   jresult = (int)result;
26370   return jresult;
26371 }
26372
26373
26374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26375   int jresult ;
26376   int result;
26377
26378   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26379   jresult = (int)result;
26380   return jresult;
26381 }
26382
26383
26384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26385   int jresult ;
26386   int result;
26387
26388   result = (int)Dali::Renderer::Property::BLEND_MODE;
26389   jresult = (int)result;
26390   return jresult;
26391 }
26392
26393
26394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26395   int jresult ;
26396   int result;
26397
26398   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26399   jresult = (int)result;
26400   return jresult;
26401 }
26402
26403
26404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26405   int jresult ;
26406   int result;
26407
26408   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26409   jresult = (int)result;
26410   return jresult;
26411 }
26412
26413
26414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26415   int jresult ;
26416   int result;
26417
26418   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26419   jresult = (int)result;
26420   return jresult;
26421 }
26422
26423
26424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26425   int jresult ;
26426   int result;
26427
26428   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26429   jresult = (int)result;
26430   return jresult;
26431 }
26432
26433
26434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26435   int jresult ;
26436   int result;
26437
26438   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26439   jresult = (int)result;
26440   return jresult;
26441 }
26442
26443
26444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26445   int jresult ;
26446   int result;
26447
26448   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26449   jresult = (int)result;
26450   return jresult;
26451 }
26452
26453
26454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26455   int jresult ;
26456   int result;
26457
26458   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26459   jresult = (int)result;
26460   return jresult;
26461 }
26462
26463
26464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26465   int jresult ;
26466   int result;
26467
26468   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26469   jresult = (int)result;
26470   return jresult;
26471 }
26472
26473
26474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26475   int jresult ;
26476   int result;
26477
26478   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26479   jresult = (int)result;
26480   return jresult;
26481 }
26482
26483
26484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26485   int jresult ;
26486   int result;
26487
26488   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26489   jresult = (int)result;
26490   return jresult;
26491 }
26492
26493
26494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26495   int jresult ;
26496   int result;
26497
26498   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26499   jresult = (int)result;
26500   return jresult;
26501 }
26502
26503
26504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26505   int jresult ;
26506   int result;
26507
26508   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26509   jresult = (int)result;
26510   return jresult;
26511 }
26512
26513
26514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26515   int jresult ;
26516   int result;
26517
26518   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26519   jresult = (int)result;
26520   return jresult;
26521 }
26522
26523
26524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26525   int jresult ;
26526   int result;
26527
26528   result = (int)Dali::Renderer::Property::RENDER_MODE;
26529   jresult = (int)result;
26530   return jresult;
26531 }
26532
26533
26534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26535   int jresult ;
26536   int result;
26537
26538   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26539   jresult = (int)result;
26540   return jresult;
26541 }
26542
26543
26544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26545   int jresult ;
26546   int result;
26547
26548   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26549   jresult = (int)result;
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26555   int jresult ;
26556   int result;
26557
26558   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26559   jresult = (int)result;
26560   return jresult;
26561 }
26562
26563
26564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26565   int jresult ;
26566   int result;
26567
26568   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26569   jresult = (int)result;
26570   return jresult;
26571 }
26572
26573
26574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26575   int jresult ;
26576   int result;
26577
26578   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26579   jresult = (int)result;
26580   return jresult;
26581 }
26582
26583
26584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26585   int jresult ;
26586   int result;
26587
26588   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26589   jresult = (int)result;
26590   return jresult;
26591 }
26592
26593
26594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26595   int jresult ;
26596   int result;
26597
26598   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26599   jresult = (int)result;
26600   return jresult;
26601 }
26602
26603
26604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26605   void * jresult ;
26606   Dali::Renderer::Property *result = 0 ;
26607
26608   {
26609     try {
26610       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26611     } catch (std::out_of_range& e) {
26612       {
26613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26614       };
26615     } catch (std::exception& e) {
26616       {
26617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26618       };
26619     } catch (Dali::DaliException e) {
26620       {
26621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26622       };
26623     } catch (...) {
26624       {
26625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26626       };
26627     }
26628   }
26629
26630   jresult = (void *)result;
26631   return jresult;
26632 }
26633
26634
26635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26636   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26637
26638   arg1 = (Dali::Renderer::Property *)jarg1;
26639   {
26640     try {
26641       delete arg1;
26642     } catch (std::out_of_range& e) {
26643       {
26644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26645       };
26646     } catch (std::exception& e) {
26647       {
26648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26649       };
26650     } catch (Dali::DaliException e) {
26651       {
26652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26653       };
26654     } catch (...) {
26655       {
26656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26657       };
26658     }
26659   }
26660
26661 }
26662
26663
26664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26665   void * jresult ;
26666   Dali::Geometry *arg1 = 0 ;
26667   Dali::Shader *arg2 = 0 ;
26668   Dali::Renderer result;
26669
26670   arg1 = (Dali::Geometry *)jarg1;
26671   if (!arg1) {
26672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26673     return 0;
26674   }
26675   arg2 = (Dali::Shader *)jarg2;
26676   if (!arg2) {
26677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26678     return 0;
26679   }
26680   {
26681     try {
26682       result = Dali::Renderer::New(*arg1,*arg2);
26683     } catch (std::out_of_range& e) {
26684       {
26685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26686       };
26687     } catch (std::exception& e) {
26688       {
26689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26690       };
26691     } catch (Dali::DaliException e) {
26692       {
26693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26694       };
26695     } catch (...) {
26696       {
26697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26698       };
26699     }
26700   }
26701
26702   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26703   return jresult;
26704 }
26705
26706
26707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26708   void * jresult ;
26709   Dali::Renderer *result = 0 ;
26710
26711   {
26712     try {
26713       result = (Dali::Renderer *)new Dali::Renderer();
26714     } catch (std::out_of_range& e) {
26715       {
26716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26717       };
26718     } catch (std::exception& e) {
26719       {
26720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26721       };
26722     } catch (Dali::DaliException e) {
26723       {
26724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26725       };
26726     } catch (...) {
26727       {
26728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26729       };
26730     }
26731   }
26732
26733   jresult = (void *)result;
26734   return jresult;
26735 }
26736
26737
26738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26739   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26740
26741   arg1 = (Dali::Renderer *)jarg1;
26742   {
26743     try {
26744       delete arg1;
26745     } catch (std::out_of_range& e) {
26746       {
26747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26748       };
26749     } catch (std::exception& e) {
26750       {
26751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26752       };
26753     } catch (Dali::DaliException e) {
26754       {
26755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26756       };
26757     } catch (...) {
26758       {
26759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26760       };
26761     }
26762   }
26763
26764 }
26765
26766
26767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26768   void * jresult ;
26769   Dali::Renderer *arg1 = 0 ;
26770   Dali::Renderer *result = 0 ;
26771
26772   arg1 = (Dali::Renderer *)jarg1;
26773   if (!arg1) {
26774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26775     return 0;
26776   }
26777   {
26778     try {
26779       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26780     } catch (std::out_of_range& e) {
26781       {
26782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26783       };
26784     } catch (std::exception& e) {
26785       {
26786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26787       };
26788     } catch (Dali::DaliException e) {
26789       {
26790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26791       };
26792     } catch (...) {
26793       {
26794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26795       };
26796     }
26797   }
26798
26799   jresult = (void *)result;
26800   return jresult;
26801 }
26802
26803
26804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26805   void * jresult ;
26806   Dali::BaseHandle arg1 ;
26807   Dali::BaseHandle *argp1 ;
26808   Dali::Renderer result;
26809
26810   argp1 = (Dali::BaseHandle *)jarg1;
26811   if (!argp1) {
26812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26813     return 0;
26814   }
26815   arg1 = *argp1;
26816   {
26817     try {
26818       result = Dali::Renderer::DownCast(arg1);
26819     } catch (std::out_of_range& e) {
26820       {
26821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26822       };
26823     } catch (std::exception& e) {
26824       {
26825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26826       };
26827     } catch (Dali::DaliException e) {
26828       {
26829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26830       };
26831     } catch (...) {
26832       {
26833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26834       };
26835     }
26836   }
26837
26838   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26839   return jresult;
26840 }
26841
26842
26843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26844   void * jresult ;
26845   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26846   Dali::Renderer *arg2 = 0 ;
26847   Dali::Renderer *result = 0 ;
26848
26849   arg1 = (Dali::Renderer *)jarg1;
26850   arg2 = (Dali::Renderer *)jarg2;
26851   if (!arg2) {
26852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26853     return 0;
26854   }
26855   {
26856     try {
26857       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26858     } catch (std::out_of_range& e) {
26859       {
26860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26861       };
26862     } catch (std::exception& e) {
26863       {
26864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26865       };
26866     } catch (Dali::DaliException e) {
26867       {
26868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26869       };
26870     } catch (...) {
26871       {
26872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26873       };
26874     }
26875   }
26876
26877   jresult = (void *)result;
26878   return jresult;
26879 }
26880
26881
26882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26883   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26884   Dali::Geometry *arg2 = 0 ;
26885
26886   arg1 = (Dali::Renderer *)jarg1;
26887   arg2 = (Dali::Geometry *)jarg2;
26888   if (!arg2) {
26889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26890     return ;
26891   }
26892   {
26893     try {
26894       (arg1)->SetGeometry(*arg2);
26895     } catch (std::out_of_range& e) {
26896       {
26897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26898       };
26899     } catch (std::exception& e) {
26900       {
26901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26902       };
26903     } catch (Dali::DaliException e) {
26904       {
26905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26906       };
26907     } catch (...) {
26908       {
26909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26910       };
26911     }
26912   }
26913
26914 }
26915
26916
26917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26918   void * jresult ;
26919   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26920   Dali::Geometry result;
26921
26922   arg1 = (Dali::Renderer *)jarg1;
26923   {
26924     try {
26925       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26926     } catch (std::out_of_range& e) {
26927       {
26928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26929       };
26930     } catch (std::exception& e) {
26931       {
26932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26933       };
26934     } catch (Dali::DaliException e) {
26935       {
26936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26937       };
26938     } catch (...) {
26939       {
26940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26941       };
26942     }
26943   }
26944
26945   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26946   return jresult;
26947 }
26948
26949
26950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26951   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26952   int arg2 ;
26953   int arg3 ;
26954
26955   arg1 = (Dali::Renderer *)jarg1;
26956   arg2 = (int)jarg2;
26957   arg3 = (int)jarg3;
26958   {
26959     try {
26960       (arg1)->SetIndexRange(arg2,arg3);
26961     } catch (std::out_of_range& e) {
26962       {
26963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26964       };
26965     } catch (std::exception& e) {
26966       {
26967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26968       };
26969     } catch (Dali::DaliException e) {
26970       {
26971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26972       };
26973     } catch (...) {
26974       {
26975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26976       };
26977     }
26978   }
26979
26980 }
26981
26982
26983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26984   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26985   Dali::TextureSet *arg2 = 0 ;
26986
26987   arg1 = (Dali::Renderer *)jarg1;
26988   arg2 = (Dali::TextureSet *)jarg2;
26989   if (!arg2) {
26990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26991     return ;
26992   }
26993   {
26994     try {
26995       (arg1)->SetTextures(*arg2);
26996     } catch (std::out_of_range& e) {
26997       {
26998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26999       };
27000     } catch (std::exception& e) {
27001       {
27002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27003       };
27004     } catch (Dali::DaliException e) {
27005       {
27006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27007       };
27008     } catch (...) {
27009       {
27010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27011       };
27012     }
27013   }
27014
27015 }
27016
27017
27018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27019   void * jresult ;
27020   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27021   Dali::TextureSet result;
27022
27023   arg1 = (Dali::Renderer *)jarg1;
27024   {
27025     try {
27026       result = ((Dali::Renderer const *)arg1)->GetTextures();
27027     } catch (std::out_of_range& e) {
27028       {
27029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27030       };
27031     } catch (std::exception& e) {
27032       {
27033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27034       };
27035     } catch (Dali::DaliException e) {
27036       {
27037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27038       };
27039     } catch (...) {
27040       {
27041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27042       };
27043     }
27044   }
27045
27046   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27047   return jresult;
27048 }
27049
27050
27051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27052   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27053   Dali::Shader *arg2 = 0 ;
27054
27055   arg1 = (Dali::Renderer *)jarg1;
27056   arg2 = (Dali::Shader *)jarg2;
27057   if (!arg2) {
27058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27059     return ;
27060   }
27061   {
27062     try {
27063       (arg1)->SetShader(*arg2);
27064     } catch (std::out_of_range& e) {
27065       {
27066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27067       };
27068     } catch (std::exception& e) {
27069       {
27070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27071       };
27072     } catch (Dali::DaliException e) {
27073       {
27074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27075       };
27076     } catch (...) {
27077       {
27078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27079       };
27080     }
27081   }
27082
27083 }
27084
27085
27086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27087   void * jresult ;
27088   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27089   Dali::Shader result;
27090
27091   arg1 = (Dali::Renderer *)jarg1;
27092   {
27093     try {
27094       result = ((Dali::Renderer const *)arg1)->GetShader();
27095     } catch (std::out_of_range& e) {
27096       {
27097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27098       };
27099     } catch (std::exception& e) {
27100       {
27101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27102       };
27103     } catch (Dali::DaliException e) {
27104       {
27105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27106       };
27107     } catch (...) {
27108       {
27109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27110       };
27111     }
27112   }
27113
27114   jresult = new Dali::Shader((const Dali::Shader &)result);
27115   return jresult;
27116 }
27117
27118
27119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27120   void * jresult ;
27121   Dali::FrameBuffer::Attachment *result = 0 ;
27122
27123   {
27124     try {
27125       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27126     } catch (std::out_of_range& e) {
27127       {
27128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27129       };
27130     } catch (std::exception& e) {
27131       {
27132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27133       };
27134     } catch (Dali::DaliException e) {
27135       {
27136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27137       };
27138     } catch (...) {
27139       {
27140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27141       };
27142     }
27143   }
27144
27145   jresult = (void *)result;
27146   return jresult;
27147 }
27148
27149
27150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27151   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27152
27153   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27154   {
27155     try {
27156       delete arg1;
27157     } catch (std::out_of_range& e) {
27158       {
27159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27160       };
27161     } catch (std::exception& e) {
27162       {
27163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27164       };
27165     } catch (Dali::DaliException e) {
27166       {
27167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27168       };
27169     } catch (...) {
27170       {
27171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27172       };
27173     }
27174   }
27175
27176 }
27177
27178
27179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27180   void * jresult ;
27181   unsigned int arg1 ;
27182   unsigned int arg2 ;
27183   unsigned int arg3 ;
27184   Dali::FrameBuffer result;
27185
27186   arg1 = (unsigned int)jarg1;
27187   arg2 = (unsigned int)jarg2;
27188   arg3 = (unsigned int)jarg3;
27189   {
27190     try {
27191       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27192     } catch (std::out_of_range& e) {
27193       {
27194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27195       };
27196     } catch (std::exception& e) {
27197       {
27198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27199       };
27200     } catch (Dali::DaliException e) {
27201       {
27202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27203       };
27204     } catch (...) {
27205       {
27206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27207       };
27208     }
27209   }
27210
27211   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27212   return jresult;
27213 }
27214
27215
27216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27217   void * jresult ;
27218   Dali::FrameBuffer *result = 0 ;
27219
27220   {
27221     try {
27222       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27223     } catch (std::out_of_range& e) {
27224       {
27225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27226       };
27227     } catch (std::exception& e) {
27228       {
27229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27230       };
27231     } catch (Dali::DaliException e) {
27232       {
27233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27234       };
27235     } catch (...) {
27236       {
27237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27238       };
27239     }
27240   }
27241
27242   jresult = (void *)result;
27243   return jresult;
27244 }
27245
27246
27247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27248   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27249
27250   arg1 = (Dali::FrameBuffer *)jarg1;
27251   {
27252     try {
27253       delete arg1;
27254     } catch (std::out_of_range& e) {
27255       {
27256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27257       };
27258     } catch (std::exception& e) {
27259       {
27260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27261       };
27262     } catch (Dali::DaliException e) {
27263       {
27264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27265       };
27266     } catch (...) {
27267       {
27268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27269       };
27270     }
27271   }
27272
27273 }
27274
27275
27276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27277   void * jresult ;
27278   Dali::FrameBuffer *arg1 = 0 ;
27279   Dali::FrameBuffer *result = 0 ;
27280
27281   arg1 = (Dali::FrameBuffer *)jarg1;
27282   if (!arg1) {
27283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27284     return 0;
27285   }
27286   {
27287     try {
27288       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27289     } catch (std::out_of_range& e) {
27290       {
27291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27292       };
27293     } catch (std::exception& e) {
27294       {
27295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27296       };
27297     } catch (Dali::DaliException e) {
27298       {
27299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27300       };
27301     } catch (...) {
27302       {
27303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27304       };
27305     }
27306   }
27307
27308   jresult = (void *)result;
27309   return jresult;
27310 }
27311
27312
27313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27314   void * jresult ;
27315   Dali::BaseHandle arg1 ;
27316   Dali::BaseHandle *argp1 ;
27317   Dali::FrameBuffer result;
27318
27319   argp1 = (Dali::BaseHandle *)jarg1;
27320   if (!argp1) {
27321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27322     return 0;
27323   }
27324   arg1 = *argp1;
27325   {
27326     try {
27327       result = Dali::FrameBuffer::DownCast(arg1);
27328     } catch (std::out_of_range& e) {
27329       {
27330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27331       };
27332     } catch (std::exception& e) {
27333       {
27334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27335       };
27336     } catch (Dali::DaliException e) {
27337       {
27338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27339       };
27340     } catch (...) {
27341       {
27342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27343       };
27344     }
27345   }
27346
27347   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27348   return jresult;
27349 }
27350
27351
27352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27353   void * jresult ;
27354   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27355   Dali::FrameBuffer *arg2 = 0 ;
27356   Dali::FrameBuffer *result = 0 ;
27357
27358   arg1 = (Dali::FrameBuffer *)jarg1;
27359   arg2 = (Dali::FrameBuffer *)jarg2;
27360   if (!arg2) {
27361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27362     return 0;
27363   }
27364   {
27365     try {
27366       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27367     } catch (std::out_of_range& e) {
27368       {
27369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27370       };
27371     } catch (std::exception& e) {
27372       {
27373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27374       };
27375     } catch (Dali::DaliException e) {
27376       {
27377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27378       };
27379     } catch (...) {
27380       {
27381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27382       };
27383     }
27384   }
27385
27386   jresult = (void *)result;
27387   return jresult;
27388 }
27389
27390
27391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27392   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27393   Dali::Texture *arg2 = 0 ;
27394
27395   arg1 = (Dali::FrameBuffer *)jarg1;
27396   arg2 = (Dali::Texture *)jarg2;
27397   if (!arg2) {
27398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27399     return ;
27400   }
27401   {
27402     try {
27403       (arg1)->AttachColorTexture(*arg2);
27404     } catch (std::out_of_range& e) {
27405       {
27406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27407       };
27408     } catch (std::exception& e) {
27409       {
27410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27411       };
27412     } catch (Dali::DaliException e) {
27413       {
27414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27415       };
27416     } catch (...) {
27417       {
27418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27419       };
27420     }
27421   }
27422
27423 }
27424
27425
27426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27427   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27428   Dali::Texture *arg2 = 0 ;
27429   unsigned int arg3 ;
27430   unsigned int arg4 ;
27431
27432   arg1 = (Dali::FrameBuffer *)jarg1;
27433   arg2 = (Dali::Texture *)jarg2;
27434   if (!arg2) {
27435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27436     return ;
27437   }
27438   arg3 = (unsigned int)jarg3;
27439   arg4 = (unsigned int)jarg4;
27440   {
27441     try {
27442       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27443     } catch (std::out_of_range& e) {
27444       {
27445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27446       };
27447     } catch (std::exception& e) {
27448       {
27449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27450       };
27451     } catch (Dali::DaliException e) {
27452       {
27453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27454       };
27455     } catch (...) {
27456       {
27457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27458       };
27459     }
27460   }
27461
27462 }
27463
27464
27465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27466   void * jresult ;
27467   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27468   Dali::Texture result;
27469
27470   arg1 = (Dali::FrameBuffer *)jarg1;
27471   {
27472     try {
27473       result = (arg1)->GetColorTexture();
27474     } catch (std::out_of_range& e) {
27475       {
27476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27477       };
27478     } catch (std::exception& e) {
27479       {
27480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27481       };
27482     } catch (Dali::DaliException e) {
27483       {
27484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27485       };
27486     } catch (...) {
27487       {
27488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27489       };
27490     }
27491   }
27492
27493   jresult = new Dali::Texture((const Dali::Texture &)result);
27494   return jresult;
27495 }
27496
27497
27498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27499   void * jresult ;
27500   Dali::RenderTaskList *result = 0 ;
27501
27502   {
27503     try {
27504       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27505     } catch (std::out_of_range& e) {
27506       {
27507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27508       };
27509     } catch (std::exception& e) {
27510       {
27511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27512       };
27513     } catch (Dali::DaliException e) {
27514       {
27515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27516       };
27517     } catch (...) {
27518       {
27519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27520       };
27521     }
27522   }
27523
27524   jresult = (void *)result;
27525   return jresult;
27526 }
27527
27528
27529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27530   void * jresult ;
27531   Dali::BaseHandle arg1 ;
27532   Dali::BaseHandle *argp1 ;
27533   Dali::RenderTaskList result;
27534
27535   argp1 = (Dali::BaseHandle *)jarg1;
27536   if (!argp1) {
27537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27538     return 0;
27539   }
27540   arg1 = *argp1;
27541   {
27542     try {
27543       result = Dali::RenderTaskList::DownCast(arg1);
27544     } catch (std::out_of_range& e) {
27545       {
27546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27547       };
27548     } catch (std::exception& e) {
27549       {
27550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27551       };
27552     } catch (Dali::DaliException e) {
27553       {
27554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27555       };
27556     } catch (...) {
27557       {
27558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27559       };
27560     }
27561   }
27562
27563   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27564   return jresult;
27565 }
27566
27567
27568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27569   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27570
27571   arg1 = (Dali::RenderTaskList *)jarg1;
27572   {
27573     try {
27574       delete arg1;
27575     } catch (std::out_of_range& e) {
27576       {
27577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27578       };
27579     } catch (std::exception& e) {
27580       {
27581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27582       };
27583     } catch (Dali::DaliException e) {
27584       {
27585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27586       };
27587     } catch (...) {
27588       {
27589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27590       };
27591     }
27592   }
27593
27594 }
27595
27596
27597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27598   void * jresult ;
27599   Dali::RenderTaskList *arg1 = 0 ;
27600   Dali::RenderTaskList *result = 0 ;
27601
27602   arg1 = (Dali::RenderTaskList *)jarg1;
27603   if (!arg1) {
27604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27605     return 0;
27606   }
27607   {
27608     try {
27609       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27610     } catch (std::out_of_range& e) {
27611       {
27612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27613       };
27614     } catch (std::exception& e) {
27615       {
27616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27617       };
27618     } catch (Dali::DaliException e) {
27619       {
27620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27621       };
27622     } catch (...) {
27623       {
27624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27625       };
27626     }
27627   }
27628
27629   jresult = (void *)result;
27630   return jresult;
27631 }
27632
27633
27634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27635   void * jresult ;
27636   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27637   Dali::RenderTaskList *arg2 = 0 ;
27638   Dali::RenderTaskList *result = 0 ;
27639
27640   arg1 = (Dali::RenderTaskList *)jarg1;
27641   arg2 = (Dali::RenderTaskList *)jarg2;
27642   if (!arg2) {
27643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27644     return 0;
27645   }
27646   {
27647     try {
27648       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27649     } catch (std::out_of_range& e) {
27650       {
27651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27652       };
27653     } catch (std::exception& e) {
27654       {
27655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27656       };
27657     } catch (Dali::DaliException e) {
27658       {
27659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27660       };
27661     } catch (...) {
27662       {
27663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27664       };
27665     }
27666   }
27667
27668   jresult = (void *)result;
27669   return jresult;
27670 }
27671
27672
27673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27674   void * jresult ;
27675   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27676   Dali::RenderTask result;
27677
27678   arg1 = (Dali::RenderTaskList *)jarg1;
27679   {
27680     try {
27681       result = (arg1)->CreateTask();
27682     } catch (std::out_of_range& e) {
27683       {
27684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27685       };
27686     } catch (std::exception& e) {
27687       {
27688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27689       };
27690     } catch (Dali::DaliException e) {
27691       {
27692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27693       };
27694     } catch (...) {
27695       {
27696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27697       };
27698     }
27699   }
27700
27701   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27702   return jresult;
27703 }
27704
27705
27706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27707   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27708   Dali::RenderTask arg2 ;
27709   Dali::RenderTask *argp2 ;
27710
27711   arg1 = (Dali::RenderTaskList *)jarg1;
27712   argp2 = (Dali::RenderTask *)jarg2;
27713   if (!argp2) {
27714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27715     return ;
27716   }
27717   arg2 = *argp2;
27718   {
27719     try {
27720       (arg1)->RemoveTask(arg2);
27721     } catch (std::out_of_range& e) {
27722       {
27723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27724       };
27725     } catch (std::exception& e) {
27726       {
27727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27728       };
27729     } catch (Dali::DaliException e) {
27730       {
27731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27732       };
27733     } catch (...) {
27734       {
27735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27736       };
27737     }
27738   }
27739
27740 }
27741
27742
27743 //// ===============================================end part 1 =================
27744
27745 //// ========================= part 2 ===============================
27746
27747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27748   unsigned int jresult ;
27749   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27750   unsigned int result;
27751
27752   arg1 = (Dali::RenderTaskList *)jarg1;
27753   {
27754     try {
27755       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27756     } catch (std::out_of_range& e) {
27757       {
27758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27759       };
27760     } catch (std::exception& e) {
27761       {
27762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27763       };
27764     } catch (Dali::DaliException e) {
27765       {
27766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27767       };
27768     } catch (...) {
27769       {
27770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27771       };
27772     }
27773   }
27774
27775   jresult = result;
27776   return jresult;
27777 }
27778
27779
27780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27781   void * jresult ;
27782   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27783   unsigned int arg2 ;
27784   Dali::RenderTask result;
27785
27786   arg1 = (Dali::RenderTaskList *)jarg1;
27787   arg2 = (unsigned int)jarg2;
27788   {
27789     try {
27790       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27791     } catch (std::out_of_range& e) {
27792       {
27793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27794       };
27795     } catch (std::exception& e) {
27796       {
27797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27798       };
27799     } catch (Dali::DaliException e) {
27800       {
27801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27802       };
27803     } catch (...) {
27804       {
27805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27806       };
27807     }
27808   }
27809
27810   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27811   return jresult;
27812 }
27813
27814
27815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27816   int jresult ;
27817   int result;
27818
27819   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27820   jresult = (int)result;
27821   return jresult;
27822 }
27823
27824
27825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27826   int jresult ;
27827   int result;
27828
27829   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27830   jresult = (int)result;
27831   return jresult;
27832 }
27833
27834
27835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27836   int jresult ;
27837   int result;
27838
27839   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27840   jresult = (int)result;
27841   return jresult;
27842 }
27843
27844
27845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27846   int jresult ;
27847   int result;
27848
27849   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27850   jresult = (int)result;
27851   return jresult;
27852 }
27853
27854
27855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27856   void * jresult ;
27857   Dali::RenderTask::Property *result = 0 ;
27858
27859   {
27860     try {
27861       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27862     } catch (std::out_of_range& e) {
27863       {
27864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27865       };
27866     } catch (std::exception& e) {
27867       {
27868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27869       };
27870     } catch (Dali::DaliException e) {
27871       {
27872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27873       };
27874     } catch (...) {
27875       {
27876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27877       };
27878     }
27879   }
27880
27881   jresult = (void *)result;
27882   return jresult;
27883 }
27884
27885
27886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27887   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27888
27889   arg1 = (Dali::RenderTask::Property *)jarg1;
27890   {
27891     try {
27892       delete arg1;
27893     } catch (std::out_of_range& e) {
27894       {
27895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27896       };
27897     } catch (std::exception& e) {
27898       {
27899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27900       };
27901     } catch (Dali::DaliException e) {
27902       {
27903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27904       };
27905     } catch (...) {
27906       {
27907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27908       };
27909     }
27910   }
27911
27912 }
27913
27914
27915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27916   void * jresult ;
27917   bool (*result)(Dali::Vector2 &) = 0 ;
27918
27919   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27920   jresult = (void *)result;
27921   return jresult;
27922 }
27923
27924
27925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27926   void * jresult ;
27927   bool (*result)(Dali::Vector2 &) = 0 ;
27928
27929   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27930   jresult = (void *)result;
27931   return jresult;
27932 }
27933
27934
27935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27936   unsigned int jresult ;
27937   bool result;
27938
27939   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27940   jresult = result;
27941   return jresult;
27942 }
27943
27944
27945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27946   unsigned int jresult ;
27947   bool result;
27948
27949   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27950   jresult = result;
27951   return jresult;
27952 }
27953
27954
27955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27956   void * jresult ;
27957   Dali::Vector4 *result = 0 ;
27958
27959   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27960   jresult = (void *)result;
27961   return jresult;
27962 }
27963
27964
27965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27966   unsigned int jresult ;
27967   bool result;
27968
27969   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27970   jresult = result;
27971   return jresult;
27972 }
27973
27974
27975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27976   unsigned int jresult ;
27977   bool result;
27978
27979   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27980   jresult = result;
27981   return jresult;
27982 }
27983
27984
27985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27986   unsigned int jresult ;
27987   unsigned int result;
27988
27989   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27990   jresult = result;
27991   return jresult;
27992 }
27993
27994
27995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27996   void * jresult ;
27997   Dali::RenderTask *result = 0 ;
27998
27999   {
28000     try {
28001       result = (Dali::RenderTask *)new Dali::RenderTask();
28002     } catch (std::out_of_range& e) {
28003       {
28004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28005       };
28006     } catch (std::exception& e) {
28007       {
28008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28009       };
28010     } catch (Dali::DaliException e) {
28011       {
28012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28013       };
28014     } catch (...) {
28015       {
28016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28017       };
28018     }
28019   }
28020
28021   jresult = (void *)result;
28022   return jresult;
28023 }
28024
28025
28026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28027   void * jresult ;
28028   Dali::BaseHandle arg1 ;
28029   Dali::BaseHandle *argp1 ;
28030   Dali::RenderTask result;
28031
28032   argp1 = (Dali::BaseHandle *)jarg1;
28033   if (!argp1) {
28034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28035     return 0;
28036   }
28037   arg1 = *argp1;
28038   {
28039     try {
28040       result = Dali::RenderTask::DownCast(arg1);
28041     } catch (std::out_of_range& e) {
28042       {
28043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28044       };
28045     } catch (std::exception& e) {
28046       {
28047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28048       };
28049     } catch (Dali::DaliException e) {
28050       {
28051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28052       };
28053     } catch (...) {
28054       {
28055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28056       };
28057     }
28058   }
28059
28060   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28061   return jresult;
28062 }
28063
28064
28065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28066   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28067
28068   arg1 = (Dali::RenderTask *)jarg1;
28069   {
28070     try {
28071       delete arg1;
28072     } catch (std::out_of_range& e) {
28073       {
28074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28075       };
28076     } catch (std::exception& e) {
28077       {
28078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28079       };
28080     } catch (Dali::DaliException e) {
28081       {
28082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28083       };
28084     } catch (...) {
28085       {
28086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28087       };
28088     }
28089   }
28090
28091 }
28092
28093
28094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28095   void * jresult ;
28096   Dali::RenderTask *arg1 = 0 ;
28097   Dali::RenderTask *result = 0 ;
28098
28099   arg1 = (Dali::RenderTask *)jarg1;
28100   if (!arg1) {
28101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28102     return 0;
28103   }
28104   {
28105     try {
28106       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28107     } catch (std::out_of_range& e) {
28108       {
28109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28110       };
28111     } catch (std::exception& e) {
28112       {
28113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28114       };
28115     } catch (Dali::DaliException e) {
28116       {
28117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28118       };
28119     } catch (...) {
28120       {
28121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28122       };
28123     }
28124   }
28125
28126   jresult = (void *)result;
28127   return jresult;
28128 }
28129
28130
28131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28132   void * jresult ;
28133   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28134   Dali::RenderTask *arg2 = 0 ;
28135   Dali::RenderTask *result = 0 ;
28136
28137   arg1 = (Dali::RenderTask *)jarg1;
28138   arg2 = (Dali::RenderTask *)jarg2;
28139   if (!arg2) {
28140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28141     return 0;
28142   }
28143   {
28144     try {
28145       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28146     } catch (std::out_of_range& e) {
28147       {
28148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28149       };
28150     } catch (std::exception& e) {
28151       {
28152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28153       };
28154     } catch (Dali::DaliException e) {
28155       {
28156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28157       };
28158     } catch (...) {
28159       {
28160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28161       };
28162     }
28163   }
28164
28165   jresult = (void *)result;
28166   return jresult;
28167 }
28168
28169
28170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28171   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28172   Dali::Actor arg2 ;
28173   Dali::Actor *argp2 ;
28174
28175   arg1 = (Dali::RenderTask *)jarg1;
28176   argp2 = (Dali::Actor *)jarg2;
28177   if (!argp2) {
28178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28179     return ;
28180   }
28181   arg2 = *argp2;
28182   {
28183     try {
28184       (arg1)->SetSourceActor(arg2);
28185     } catch (std::out_of_range& e) {
28186       {
28187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28188       };
28189     } catch (std::exception& e) {
28190       {
28191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28192       };
28193     } catch (Dali::DaliException e) {
28194       {
28195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28196       };
28197     } catch (...) {
28198       {
28199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28200       };
28201     }
28202   }
28203
28204 }
28205
28206
28207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28208   void * jresult ;
28209   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28210   Dali::Actor result;
28211
28212   arg1 = (Dali::RenderTask *)jarg1;
28213   {
28214     try {
28215       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28216     } catch (std::out_of_range& e) {
28217       {
28218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28219       };
28220     } catch (std::exception& e) {
28221       {
28222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28223       };
28224     } catch (Dali::DaliException e) {
28225       {
28226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28227       };
28228     } catch (...) {
28229       {
28230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28231       };
28232     }
28233   }
28234
28235   jresult = new Dali::Actor((const Dali::Actor &)result);
28236   return jresult;
28237 }
28238
28239
28240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28241   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28242   bool arg2 ;
28243
28244   arg1 = (Dali::RenderTask *)jarg1;
28245   arg2 = jarg2 ? true : false;
28246   {
28247     try {
28248       (arg1)->SetExclusive(arg2);
28249     } catch (std::out_of_range& e) {
28250       {
28251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28252       };
28253     } catch (std::exception& e) {
28254       {
28255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28256       };
28257     } catch (Dali::DaliException e) {
28258       {
28259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28260       };
28261     } catch (...) {
28262       {
28263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28264       };
28265     }
28266   }
28267
28268 }
28269
28270
28271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28272   unsigned int jresult ;
28273   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28274   bool result;
28275
28276   arg1 = (Dali::RenderTask *)jarg1;
28277   {
28278     try {
28279       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28280     } catch (std::out_of_range& e) {
28281       {
28282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28283       };
28284     } catch (std::exception& e) {
28285       {
28286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28287       };
28288     } catch (Dali::DaliException e) {
28289       {
28290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28291       };
28292     } catch (...) {
28293       {
28294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28295       };
28296     }
28297   }
28298
28299   jresult = result;
28300   return jresult;
28301 }
28302
28303
28304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28305   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28306   bool arg2 ;
28307
28308   arg1 = (Dali::RenderTask *)jarg1;
28309   arg2 = jarg2 ? true : false;
28310   {
28311     try {
28312       (arg1)->SetInputEnabled(arg2);
28313     } catch (std::out_of_range& e) {
28314       {
28315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28316       };
28317     } catch (std::exception& e) {
28318       {
28319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28320       };
28321     } catch (Dali::DaliException e) {
28322       {
28323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28324       };
28325     } catch (...) {
28326       {
28327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28328       };
28329     }
28330   }
28331
28332 }
28333
28334
28335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28336   unsigned int jresult ;
28337   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28338   bool result;
28339
28340   arg1 = (Dali::RenderTask *)jarg1;
28341   {
28342     try {
28343       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28344     } catch (std::out_of_range& e) {
28345       {
28346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28347       };
28348     } catch (std::exception& e) {
28349       {
28350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28351       };
28352     } catch (Dali::DaliException e) {
28353       {
28354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28355       };
28356     } catch (...) {
28357       {
28358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28359       };
28360     }
28361   }
28362
28363   jresult = result;
28364   return jresult;
28365 }
28366
28367
28368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28369   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28370   Dali::CameraActor arg2 ;
28371   Dali::CameraActor *argp2 ;
28372
28373   arg1 = (Dali::RenderTask *)jarg1;
28374   argp2 = (Dali::CameraActor *)jarg2;
28375   if (!argp2) {
28376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28377     return ;
28378   }
28379   arg2 = *argp2;
28380   {
28381     try {
28382       (arg1)->SetCameraActor(arg2);
28383     } catch (std::out_of_range& e) {
28384       {
28385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28386       };
28387     } catch (std::exception& e) {
28388       {
28389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28390       };
28391     } catch (Dali::DaliException e) {
28392       {
28393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28394       };
28395     } catch (...) {
28396       {
28397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28398       };
28399     }
28400   }
28401
28402 }
28403
28404
28405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28406   void * jresult ;
28407   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28408   Dali::CameraActor result;
28409
28410   arg1 = (Dali::RenderTask *)jarg1;
28411   {
28412     try {
28413       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28414     } catch (std::out_of_range& e) {
28415       {
28416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28417       };
28418     } catch (std::exception& e) {
28419       {
28420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28421       };
28422     } catch (Dali::DaliException e) {
28423       {
28424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28425       };
28426     } catch (...) {
28427       {
28428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28429       };
28430     }
28431   }
28432
28433   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28434   return jresult;
28435 }
28436
28437
28438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28439   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28440   Dali::FrameBufferImage arg2 ;
28441   Dali::FrameBufferImage *argp2 ;
28442
28443   arg1 = (Dali::RenderTask *)jarg1;
28444   argp2 = (Dali::FrameBufferImage *)jarg2;
28445   if (!argp2) {
28446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28447     return ;
28448   }
28449   arg2 = *argp2;
28450   {
28451     try {
28452       (arg1)->SetTargetFrameBuffer(arg2);
28453     } catch (std::out_of_range& e) {
28454       {
28455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28456       };
28457     } catch (std::exception& e) {
28458       {
28459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28460       };
28461     } catch (Dali::DaliException e) {
28462       {
28463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28464       };
28465     } catch (...) {
28466       {
28467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28468       };
28469     }
28470   }
28471
28472 }
28473
28474
28475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28476   void * jresult ;
28477   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28478   Dali::FrameBufferImage result;
28479
28480   arg1 = (Dali::RenderTask *)jarg1;
28481   {
28482     try {
28483       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28484     } catch (std::out_of_range& e) {
28485       {
28486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28487       };
28488     } catch (std::exception& e) {
28489       {
28490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28491       };
28492     } catch (Dali::DaliException e) {
28493       {
28494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28495       };
28496     } catch (...) {
28497       {
28498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28499       };
28500     }
28501   }
28502
28503   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28504   return jresult;
28505 }
28506
28507
28508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28509   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28510   Dali::FrameBuffer arg2 ;
28511   Dali::FrameBuffer *argp2 ;
28512
28513   arg1 = (Dali::RenderTask *)jarg1;
28514   argp2 = (Dali::FrameBuffer *)jarg2;
28515   if (!argp2) {
28516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28517     return ;
28518   }
28519   arg2 = *argp2;
28520   {
28521     try {
28522       (arg1)->SetFrameBuffer(arg2);
28523     } catch (std::out_of_range& e) {
28524       {
28525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28526       };
28527     } catch (std::exception& e) {
28528       {
28529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28530       };
28531     } catch (Dali::DaliException e) {
28532       {
28533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28534       };
28535     } catch (...) {
28536       {
28537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28538       };
28539     }
28540   }
28541
28542 }
28543
28544
28545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28546   void * jresult ;
28547   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28548   Dali::FrameBuffer result;
28549
28550   arg1 = (Dali::RenderTask *)jarg1;
28551   {
28552     try {
28553       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28554     } catch (std::out_of_range& e) {
28555       {
28556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28557       };
28558     } catch (std::exception& e) {
28559       {
28560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28561       };
28562     } catch (Dali::DaliException e) {
28563       {
28564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28565       };
28566     } catch (...) {
28567       {
28568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28569       };
28570     }
28571   }
28572
28573   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28574   return jresult;
28575 }
28576
28577
28578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28579   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28580   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28581
28582   arg1 = (Dali::RenderTask *)jarg1;
28583   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28584   {
28585     try {
28586       (arg1)->SetScreenToFrameBufferFunction(arg2);
28587     } catch (std::out_of_range& e) {
28588       {
28589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28590       };
28591     } catch (std::exception& e) {
28592       {
28593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28594       };
28595     } catch (Dali::DaliException e) {
28596       {
28597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28598       };
28599     } catch (...) {
28600       {
28601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28602       };
28603     }
28604   }
28605
28606 }
28607
28608
28609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28610   void * jresult ;
28611   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28612   Dali::RenderTask::ScreenToFrameBufferFunction result;
28613
28614   arg1 = (Dali::RenderTask *)jarg1;
28615   {
28616     try {
28617       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28618     } catch (std::out_of_range& e) {
28619       {
28620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28621       };
28622     } catch (std::exception& e) {
28623       {
28624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28625       };
28626     } catch (Dali::DaliException e) {
28627       {
28628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28629       };
28630     } catch (...) {
28631       {
28632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28633       };
28634     }
28635   }
28636
28637   jresult = (void *)result;
28638   return jresult;
28639 }
28640
28641
28642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28643   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28644   Dali::Actor arg2 ;
28645   Dali::Actor *argp2 ;
28646
28647   arg1 = (Dali::RenderTask *)jarg1;
28648   argp2 = (Dali::Actor *)jarg2;
28649   if (!argp2) {
28650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28651     return ;
28652   }
28653   arg2 = *argp2;
28654   {
28655     try {
28656       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28657     } catch (std::out_of_range& e) {
28658       {
28659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28660       };
28661     } catch (std::exception& e) {
28662       {
28663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28664       };
28665     } catch (Dali::DaliException e) {
28666       {
28667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28668       };
28669     } catch (...) {
28670       {
28671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28672       };
28673     }
28674   }
28675
28676 }
28677
28678
28679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28680   void * jresult ;
28681   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28682   Dali::Actor result;
28683
28684   arg1 = (Dali::RenderTask *)jarg1;
28685   {
28686     try {
28687       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28688     } catch (std::out_of_range& e) {
28689       {
28690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28691       };
28692     } catch (std::exception& e) {
28693       {
28694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28695       };
28696     } catch (Dali::DaliException e) {
28697       {
28698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28699       };
28700     } catch (...) {
28701       {
28702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28703       };
28704     }
28705   }
28706
28707   jresult = new Dali::Actor((const Dali::Actor &)result);
28708   return jresult;
28709 }
28710
28711
28712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28713   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28714   Dali::Vector2 arg2 ;
28715   Dali::Vector2 *argp2 ;
28716
28717   arg1 = (Dali::RenderTask *)jarg1;
28718   argp2 = (Dali::Vector2 *)jarg2;
28719   if (!argp2) {
28720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28721     return ;
28722   }
28723   arg2 = *argp2;
28724   {
28725     try {
28726       (arg1)->SetViewportPosition(arg2);
28727     } catch (std::out_of_range& e) {
28728       {
28729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28730       };
28731     } catch (std::exception& e) {
28732       {
28733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28734       };
28735     } catch (Dali::DaliException e) {
28736       {
28737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28738       };
28739     } catch (...) {
28740       {
28741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28742       };
28743     }
28744   }
28745
28746 }
28747
28748
28749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28750   void * jresult ;
28751   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28752   Dali::Vector2 result;
28753
28754   arg1 = (Dali::RenderTask *)jarg1;
28755   {
28756     try {
28757       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28758     } catch (std::out_of_range& e) {
28759       {
28760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28761       };
28762     } catch (std::exception& e) {
28763       {
28764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28765       };
28766     } catch (Dali::DaliException e) {
28767       {
28768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28769       };
28770     } catch (...) {
28771       {
28772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28773       };
28774     }
28775   }
28776
28777   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28778   return jresult;
28779 }
28780
28781
28782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28783   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28784   Dali::Vector2 arg2 ;
28785   Dali::Vector2 *argp2 ;
28786
28787   arg1 = (Dali::RenderTask *)jarg1;
28788   argp2 = (Dali::Vector2 *)jarg2;
28789   if (!argp2) {
28790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28791     return ;
28792   }
28793   arg2 = *argp2;
28794   {
28795     try {
28796       (arg1)->SetViewportSize(arg2);
28797     } catch (std::out_of_range& e) {
28798       {
28799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28800       };
28801     } catch (std::exception& e) {
28802       {
28803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28804       };
28805     } catch (Dali::DaliException e) {
28806       {
28807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28808       };
28809     } catch (...) {
28810       {
28811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28812       };
28813     }
28814   }
28815
28816 }
28817
28818
28819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28820   void * jresult ;
28821   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28822   Dali::Vector2 result;
28823
28824   arg1 = (Dali::RenderTask *)jarg1;
28825   {
28826     try {
28827       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28828     } catch (std::out_of_range& e) {
28829       {
28830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28831       };
28832     } catch (std::exception& e) {
28833       {
28834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28835       };
28836     } catch (Dali::DaliException e) {
28837       {
28838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28839       };
28840     } catch (...) {
28841       {
28842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28843       };
28844     }
28845   }
28846
28847   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28848   return jresult;
28849 }
28850
28851
28852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28853   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28854   Dali::Viewport arg2 ;
28855   Dali::Viewport *argp2 ;
28856
28857   arg1 = (Dali::RenderTask *)jarg1;
28858   argp2 = (Dali::Viewport *)jarg2;
28859   if (!argp2) {
28860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28861     return ;
28862   }
28863   arg2 = *argp2;
28864   {
28865     try {
28866       (arg1)->SetViewport(arg2);
28867     } catch (std::out_of_range& e) {
28868       {
28869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28870       };
28871     } catch (std::exception& e) {
28872       {
28873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28874       };
28875     } catch (Dali::DaliException e) {
28876       {
28877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28878       };
28879     } catch (...) {
28880       {
28881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28882       };
28883     }
28884   }
28885
28886 }
28887
28888
28889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28890   void * jresult ;
28891   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28892   Dali::Viewport result;
28893
28894   arg1 = (Dali::RenderTask *)jarg1;
28895   {
28896     try {
28897       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28898     } catch (std::out_of_range& e) {
28899       {
28900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28901       };
28902     } catch (std::exception& e) {
28903       {
28904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28905       };
28906     } catch (Dali::DaliException e) {
28907       {
28908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28909       };
28910     } catch (...) {
28911       {
28912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28913       };
28914     }
28915   }
28916
28917   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28918   return jresult;
28919 }
28920
28921
28922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28923   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28924   Dali::Vector4 *arg2 = 0 ;
28925
28926   arg1 = (Dali::RenderTask *)jarg1;
28927   arg2 = (Dali::Vector4 *)jarg2;
28928   if (!arg2) {
28929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28930     return ;
28931   }
28932   {
28933     try {
28934       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28935     } catch (std::out_of_range& e) {
28936       {
28937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28938       };
28939     } catch (std::exception& e) {
28940       {
28941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28942       };
28943     } catch (Dali::DaliException e) {
28944       {
28945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28946       };
28947     } catch (...) {
28948       {
28949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28950       };
28951     }
28952   }
28953
28954 }
28955
28956
28957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28958   void * jresult ;
28959   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28960   Dali::Vector4 result;
28961
28962   arg1 = (Dali::RenderTask *)jarg1;
28963   {
28964     try {
28965       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28966     } catch (std::out_of_range& e) {
28967       {
28968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28969       };
28970     } catch (std::exception& e) {
28971       {
28972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28973       };
28974     } catch (Dali::DaliException e) {
28975       {
28976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28977       };
28978     } catch (...) {
28979       {
28980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28981       };
28982     }
28983   }
28984
28985   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28986   return jresult;
28987 }
28988
28989
28990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28991   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28992   bool arg2 ;
28993
28994   arg1 = (Dali::RenderTask *)jarg1;
28995   arg2 = jarg2 ? true : false;
28996   {
28997     try {
28998       (arg1)->SetClearEnabled(arg2);
28999     } catch (std::out_of_range& e) {
29000       {
29001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29002       };
29003     } catch (std::exception& e) {
29004       {
29005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29006       };
29007     } catch (Dali::DaliException e) {
29008       {
29009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29010       };
29011     } catch (...) {
29012       {
29013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29014       };
29015     }
29016   }
29017
29018 }
29019
29020
29021 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29022   unsigned int jresult ;
29023   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29024   bool result;
29025
29026   arg1 = (Dali::RenderTask *)jarg1;
29027   {
29028     try {
29029       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29030     } catch (std::out_of_range& e) {
29031       {
29032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29033       };
29034     } catch (std::exception& e) {
29035       {
29036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29037       };
29038     } catch (Dali::DaliException e) {
29039       {
29040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29041       };
29042     } catch (...) {
29043       {
29044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29045       };
29046     }
29047   }
29048
29049   jresult = result;
29050   return jresult;
29051 }
29052
29053
29054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29055   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29056   bool arg2 ;
29057
29058   arg1 = (Dali::RenderTask *)jarg1;
29059   arg2 = jarg2 ? true : false;
29060   {
29061     try {
29062       (arg1)->SetCullMode(arg2);
29063     } catch (std::out_of_range& e) {
29064       {
29065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29066       };
29067     } catch (std::exception& e) {
29068       {
29069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29070       };
29071     } catch (Dali::DaliException e) {
29072       {
29073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29074       };
29075     } catch (...) {
29076       {
29077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29078       };
29079     }
29080   }
29081
29082 }
29083
29084
29085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29086   unsigned int jresult ;
29087   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29088   bool result;
29089
29090   arg1 = (Dali::RenderTask *)jarg1;
29091   {
29092     try {
29093       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29094     } catch (std::out_of_range& e) {
29095       {
29096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29097       };
29098     } catch (std::exception& e) {
29099       {
29100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29101       };
29102     } catch (Dali::DaliException e) {
29103       {
29104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29105       };
29106     } catch (...) {
29107       {
29108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29109       };
29110     }
29111   }
29112
29113   jresult = result;
29114   return jresult;
29115 }
29116
29117
29118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29119   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29120   unsigned int arg2 ;
29121
29122   arg1 = (Dali::RenderTask *)jarg1;
29123   arg2 = (unsigned int)jarg2;
29124   {
29125     try {
29126       (arg1)->SetRefreshRate(arg2);
29127     } catch (std::out_of_range& e) {
29128       {
29129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29130       };
29131     } catch (std::exception& e) {
29132       {
29133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29134       };
29135     } catch (Dali::DaliException e) {
29136       {
29137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29138       };
29139     } catch (...) {
29140       {
29141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29142       };
29143     }
29144   }
29145
29146 }
29147
29148
29149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29150   unsigned int jresult ;
29151   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29152   unsigned int result;
29153
29154   arg1 = (Dali::RenderTask *)jarg1;
29155   {
29156     try {
29157       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29158     } catch (std::out_of_range& e) {
29159       {
29160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29161       };
29162     } catch (std::exception& e) {
29163       {
29164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29165       };
29166     } catch (Dali::DaliException e) {
29167       {
29168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29169       };
29170     } catch (...) {
29171       {
29172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29173       };
29174     }
29175   }
29176
29177   jresult = result;
29178   return jresult;
29179 }
29180
29181
29182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29183   unsigned int jresult ;
29184   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29185   Dali::Vector3 *arg2 = 0 ;
29186   float *arg3 = 0 ;
29187   float *arg4 = 0 ;
29188   bool result;
29189
29190   arg1 = (Dali::RenderTask *)jarg1;
29191   arg2 = (Dali::Vector3 *)jarg2;
29192   if (!arg2) {
29193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29194     return 0;
29195   }
29196   arg3 = (float *)jarg3;
29197   arg4 = (float *)jarg4;
29198   {
29199     try {
29200       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29201     } catch (std::out_of_range& e) {
29202       {
29203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29204       };
29205     } catch (std::exception& e) {
29206       {
29207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29208       };
29209     } catch (Dali::DaliException e) {
29210       {
29211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29212       };
29213     } catch (...) {
29214       {
29215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29216       };
29217     }
29218   }
29219
29220   jresult = result;
29221   return jresult;
29222 }
29223
29224
29225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29226   unsigned int jresult ;
29227   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29228   Dali::Actor arg2 ;
29229   float arg3 ;
29230   float arg4 ;
29231   float *arg5 = 0 ;
29232   float *arg6 = 0 ;
29233   Dali::Actor *argp2 ;
29234   bool result;
29235
29236   arg1 = (Dali::RenderTask *)jarg1;
29237   argp2 = (Dali::Actor *)jarg2;
29238   if (!argp2) {
29239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29240     return 0;
29241   }
29242   arg2 = *argp2;
29243   arg3 = (float)jarg3;
29244   arg4 = (float)jarg4;
29245   arg5 = (float *)jarg5;
29246   arg6 = (float *)jarg6;
29247   {
29248     try {
29249       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29250     } catch (std::out_of_range& e) {
29251       {
29252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29253       };
29254     } catch (std::exception& e) {
29255       {
29256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29257       };
29258     } catch (Dali::DaliException e) {
29259       {
29260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29261       };
29262     } catch (...) {
29263       {
29264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29265       };
29266     }
29267   }
29268
29269   jresult = result;
29270   return jresult;
29271 }
29272
29273
29274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29275   void * jresult ;
29276   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29277   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29278
29279   arg1 = (Dali::RenderTask *)jarg1;
29280   {
29281     try {
29282       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29283     } catch (std::out_of_range& e) {
29284       {
29285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29286       };
29287     } catch (std::exception& e) {
29288       {
29289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29290       };
29291     } catch (Dali::DaliException e) {
29292       {
29293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29294       };
29295     } catch (...) {
29296       {
29297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29298       };
29299     }
29300   }
29301
29302   jresult = (void *)result;
29303   return jresult;
29304 }
29305
29306
29307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29308   void * jresult ;
29309   int arg1 ;
29310   Dali::TouchPoint::State arg2 ;
29311   float arg3 ;
29312   float arg4 ;
29313   Dali::TouchPoint *result = 0 ;
29314
29315   arg1 = (int)jarg1;
29316   arg2 = (Dali::TouchPoint::State)jarg2;
29317   arg3 = (float)jarg3;
29318   arg4 = (float)jarg4;
29319   {
29320     try {
29321       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29322     } catch (std::out_of_range& e) {
29323       {
29324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29325       };
29326     } catch (std::exception& e) {
29327       {
29328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29329       };
29330     } catch (Dali::DaliException e) {
29331       {
29332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29333       };
29334     } catch (...) {
29335       {
29336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29337       };
29338     }
29339   }
29340
29341   jresult = (void *)result;
29342   return jresult;
29343 }
29344
29345
29346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29347   void * jresult ;
29348   int arg1 ;
29349   Dali::TouchPoint::State arg2 ;
29350   float arg3 ;
29351   float arg4 ;
29352   float arg5 ;
29353   float arg6 ;
29354   Dali::TouchPoint *result = 0 ;
29355
29356   arg1 = (int)jarg1;
29357   arg2 = (Dali::TouchPoint::State)jarg2;
29358   arg3 = (float)jarg3;
29359   arg4 = (float)jarg4;
29360   arg5 = (float)jarg5;
29361   arg6 = (float)jarg6;
29362   {
29363     try {
29364       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29365     } catch (std::out_of_range& e) {
29366       {
29367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29368       };
29369     } catch (std::exception& e) {
29370       {
29371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29372       };
29373     } catch (Dali::DaliException e) {
29374       {
29375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29376       };
29377     } catch (...) {
29378       {
29379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29380       };
29381     }
29382   }
29383
29384   jresult = (void *)result;
29385   return jresult;
29386 }
29387
29388
29389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29390   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29391
29392   arg1 = (Dali::TouchPoint *)jarg1;
29393   {
29394     try {
29395       delete arg1;
29396     } catch (std::out_of_range& e) {
29397       {
29398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29399       };
29400     } catch (std::exception& e) {
29401       {
29402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29403       };
29404     } catch (Dali::DaliException e) {
29405       {
29406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29407       };
29408     } catch (...) {
29409       {
29410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29411       };
29412     }
29413   }
29414
29415 }
29416
29417
29418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29419   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29420   int arg2 ;
29421
29422   arg1 = (Dali::TouchPoint *)jarg1;
29423   arg2 = (int)jarg2;
29424   if (arg1) (arg1)->deviceId = arg2;
29425 }
29426
29427
29428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29429   int jresult ;
29430   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29431   int result;
29432
29433   arg1 = (Dali::TouchPoint *)jarg1;
29434   result = (int) ((arg1)->deviceId);
29435   jresult = result;
29436   return jresult;
29437 }
29438
29439
29440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29441   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29442   Dali::TouchPoint::State arg2 ;
29443
29444   arg1 = (Dali::TouchPoint *)jarg1;
29445   arg2 = (Dali::TouchPoint::State)jarg2;
29446   if (arg1) (arg1)->state = arg2;
29447 }
29448
29449
29450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29451   int jresult ;
29452   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29453   Dali::TouchPoint::State result;
29454
29455   arg1 = (Dali::TouchPoint *)jarg1;
29456   result = (Dali::TouchPoint::State) ((arg1)->state);
29457   jresult = (int)result;
29458   return jresult;
29459 }
29460
29461
29462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29463   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29464   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29465
29466   arg1 = (Dali::TouchPoint *)jarg1;
29467   arg2 = (Dali::Actor *)jarg2;
29468   if (arg1) (arg1)->hitActor = *arg2;
29469 }
29470
29471
29472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29473   void * jresult ;
29474   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29475   Dali::Actor *result = 0 ;
29476
29477   arg1 = (Dali::TouchPoint *)jarg1;
29478   result = (Dali::Actor *)& ((arg1)->hitActor);
29479   jresult = (void *)result;
29480   return jresult;
29481 }
29482
29483
29484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29485   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29486   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29487
29488   arg1 = (Dali::TouchPoint *)jarg1;
29489   arg2 = (Dali::Vector2 *)jarg2;
29490   if (arg1) (arg1)->local = *arg2;
29491 }
29492
29493
29494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29495   void * jresult ;
29496   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29497   Dali::Vector2 *result = 0 ;
29498
29499   arg1 = (Dali::TouchPoint *)jarg1;
29500   result = (Dali::Vector2 *)& ((arg1)->local);
29501   jresult = (void *)result;
29502   return jresult;
29503 }
29504
29505
29506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29507   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29508   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29509
29510   arg1 = (Dali::TouchPoint *)jarg1;
29511   arg2 = (Dali::Vector2 *)jarg2;
29512   if (arg1) (arg1)->screen = *arg2;
29513 }
29514
29515
29516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29517   void * jresult ;
29518   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29519   Dali::Vector2 *result = 0 ;
29520
29521   arg1 = (Dali::TouchPoint *)jarg1;
29522   result = (Dali::Vector2 *)& ((arg1)->screen);
29523   jresult = (void *)result;
29524   return jresult;
29525 }
29526
29527
29528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29529   void * jresult ;
29530   Dali::TouchData *result = 0 ;
29531
29532   {
29533     try {
29534       result = (Dali::TouchData *)new Dali::TouchData();
29535     } catch (std::out_of_range& e) {
29536       {
29537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29538       };
29539     } catch (std::exception& e) {
29540       {
29541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29542       };
29543     } catch (Dali::DaliException e) {
29544       {
29545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29546       };
29547     } catch (...) {
29548       {
29549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29550       };
29551     }
29552   }
29553
29554   jresult = (void *)result;
29555   return jresult;
29556 }
29557
29558
29559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29560   void * jresult ;
29561   Dali::TouchData *arg1 = 0 ;
29562   Dali::TouchData *result = 0 ;
29563
29564   arg1 = (Dali::TouchData *)jarg1;
29565   if (!arg1) {
29566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29567     return 0;
29568   }
29569   {
29570     try {
29571       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29572     } catch (std::out_of_range& e) {
29573       {
29574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29575       };
29576     } catch (std::exception& e) {
29577       {
29578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29579       };
29580     } catch (Dali::DaliException e) {
29581       {
29582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29583       };
29584     } catch (...) {
29585       {
29586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29587       };
29588     }
29589   }
29590
29591   jresult = (void *)result;
29592   return jresult;
29593 }
29594
29595
29596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29597   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29598
29599   arg1 = (Dali::TouchData *)jarg1;
29600   {
29601     try {
29602       delete arg1;
29603     } catch (std::out_of_range& e) {
29604       {
29605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29606       };
29607     } catch (std::exception& e) {
29608       {
29609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29610       };
29611     } catch (Dali::DaliException e) {
29612       {
29613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29614       };
29615     } catch (...) {
29616       {
29617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29618       };
29619     }
29620   }
29621
29622 }
29623
29624
29625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29626   void * jresult ;
29627   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29628   Dali::TouchData *arg2 = 0 ;
29629   Dali::TouchData *result = 0 ;
29630
29631   arg1 = (Dali::TouchData *)jarg1;
29632   arg2 = (Dali::TouchData *)jarg2;
29633   if (!arg2) {
29634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29635     return 0;
29636   }
29637   {
29638     try {
29639       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29640     } catch (std::out_of_range& e) {
29641       {
29642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29643       };
29644     } catch (std::exception& e) {
29645       {
29646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29647       };
29648     } catch (Dali::DaliException e) {
29649       {
29650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29651       };
29652     } catch (...) {
29653       {
29654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29655       };
29656     }
29657   }
29658
29659   jresult = (void *)result;
29660   return jresult;
29661 }
29662
29663
29664 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29665   unsigned long jresult ;
29666   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29667   unsigned long result;
29668
29669   arg1 = (Dali::TouchData *)jarg1;
29670   {
29671     try {
29672       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29673     } catch (std::out_of_range& e) {
29674       {
29675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29676       };
29677     } catch (std::exception& e) {
29678       {
29679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29680       };
29681     } catch (Dali::DaliException e) {
29682       {
29683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29684       };
29685     } catch (...) {
29686       {
29687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29688       };
29689     }
29690   }
29691
29692   jresult = (unsigned long)result;
29693   return jresult;
29694 }
29695
29696
29697 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29698   unsigned long jresult ;
29699   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29700   std::size_t result;
29701
29702   arg1 = (Dali::TouchData *)jarg1;
29703   {
29704     try {
29705       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29706     } catch (std::out_of_range& e) {
29707       {
29708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29709       };
29710     } catch (std::exception& e) {
29711       {
29712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29713       };
29714     } catch (Dali::DaliException e) {
29715       {
29716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29717       };
29718     } catch (...) {
29719       {
29720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29721       };
29722     }
29723   }
29724
29725   jresult = (unsigned long)result;
29726   return jresult;
29727 }
29728
29729
29730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29731   int jresult ;
29732   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29733   std::size_t arg2 ;
29734   int32_t result;
29735
29736   arg1 = (Dali::TouchData *)jarg1;
29737   arg2 = (std::size_t)jarg2;
29738   {
29739     try {
29740       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29741     } catch (std::out_of_range& e) {
29742       {
29743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29744       };
29745     } catch (std::exception& e) {
29746       {
29747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29748       };
29749     } catch (Dali::DaliException e) {
29750       {
29751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29752       };
29753     } catch (...) {
29754       {
29755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29756       };
29757     }
29758   }
29759
29760   jresult = result;
29761   return jresult;
29762 }
29763
29764
29765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29766   int jresult ;
29767   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29768   std::size_t arg2 ;
29769   Dali::PointState::Type result;
29770
29771   arg1 = (Dali::TouchData *)jarg1;
29772   arg2 = (std::size_t)jarg2;
29773   {
29774     try {
29775       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29776     } catch (std::out_of_range& e) {
29777       {
29778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29779       };
29780     } catch (std::exception& e) {
29781       {
29782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29783       };
29784     } catch (Dali::DaliException e) {
29785       {
29786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29787       };
29788     } catch (...) {
29789       {
29790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29791       };
29792     }
29793   }
29794
29795   jresult = (int)result;
29796   return jresult;
29797 }
29798
29799
29800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29801   void * jresult ;
29802   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29803   std::size_t arg2 ;
29804   Dali::Actor result;
29805
29806   arg1 = (Dali::TouchData *)jarg1;
29807   arg2 = (std::size_t)jarg2;
29808   {
29809     try {
29810       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29811     } catch (std::out_of_range& e) {
29812       {
29813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29814       };
29815     } catch (std::exception& e) {
29816       {
29817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29818       };
29819     } catch (Dali::DaliException e) {
29820       {
29821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29822       };
29823     } catch (...) {
29824       {
29825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29826       };
29827     }
29828   }
29829
29830   jresult = new Dali::Actor((const Dali::Actor &)result);
29831   return jresult;
29832 }
29833
29834
29835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29836   void * jresult ;
29837   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29838   std::size_t arg2 ;
29839   Dali::Vector2 *result = 0 ;
29840
29841   arg1 = (Dali::TouchData *)jarg1;
29842   arg2 = (std::size_t)jarg2;
29843   {
29844     try {
29845       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
29846     } catch (std::out_of_range& e) {
29847       {
29848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29849       };
29850     } catch (std::exception& e) {
29851       {
29852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29853       };
29854     } catch (Dali::DaliException e) {
29855       {
29856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29857       };
29858     } catch (...) {
29859       {
29860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29861       };
29862     }
29863   }
29864
29865   jresult = (void *)result;
29866   return jresult;
29867 }
29868
29869
29870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29871   void * jresult ;
29872   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29873   std::size_t arg2 ;
29874   Dali::Vector2 *result = 0 ;
29875
29876   arg1 = (Dali::TouchData *)jarg1;
29877   arg2 = (std::size_t)jarg2;
29878   {
29879     try {
29880       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
29881     } catch (std::out_of_range& e) {
29882       {
29883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29884       };
29885     } catch (std::exception& e) {
29886       {
29887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29888       };
29889     } catch (Dali::DaliException e) {
29890       {
29891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29892       };
29893     } catch (...) {
29894       {
29895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29896       };
29897     }
29898   }
29899
29900   jresult = (void *)result;
29901   return jresult;
29902 }
29903
29904
29905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29906   float jresult ;
29907   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29908   std::size_t arg2 ;
29909   float result;
29910
29911   arg1 = (Dali::TouchData *)jarg1;
29912   arg2 = (std::size_t)jarg2;
29913   {
29914     try {
29915       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
29916     } catch (std::out_of_range& e) {
29917       {
29918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29919       };
29920     } catch (std::exception& e) {
29921       {
29922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29923       };
29924     } catch (Dali::DaliException e) {
29925       {
29926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29927       };
29928     } catch (...) {
29929       {
29930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29931       };
29932     }
29933   }
29934
29935   jresult = result;
29936   return jresult;
29937 }
29938
29939
29940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29941   void * jresult ;
29942   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29943   std::size_t arg2 ;
29944   Dali::Vector2 *result = 0 ;
29945
29946   arg1 = (Dali::TouchData *)jarg1;
29947   arg2 = (std::size_t)jarg2;
29948   {
29949     try {
29950       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
29951     } catch (std::out_of_range& e) {
29952       {
29953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29954       };
29955     } catch (std::exception& e) {
29956       {
29957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29958       };
29959     } catch (Dali::DaliException e) {
29960       {
29961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29962       };
29963     } catch (...) {
29964       {
29965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29966       };
29967     }
29968   }
29969
29970   jresult = (void *)result;
29971   return jresult;
29972 }
29973
29974
29975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29976   float jresult ;
29977   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29978   std::size_t arg2 ;
29979   float result;
29980
29981   arg1 = (Dali::TouchData *)jarg1;
29982   arg2 = (std::size_t)jarg2;
29983   {
29984     try {
29985       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
29986     } catch (std::out_of_range& e) {
29987       {
29988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29989       };
29990     } catch (std::exception& e) {
29991       {
29992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29993       };
29994     } catch (Dali::DaliException e) {
29995       {
29996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29997       };
29998     } catch (...) {
29999       {
30000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30001       };
30002     }
30003   }
30004
30005   jresult = result;
30006   return jresult;
30007 }
30008
30009
30010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30011   void * jresult ;
30012   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30013   std::size_t arg2 ;
30014   Dali::Degree result;
30015
30016   arg1 = (Dali::TouchData *)jarg1;
30017   arg2 = (std::size_t)jarg2;
30018   {
30019     try {
30020       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30021     } catch (std::out_of_range& e) {
30022       {
30023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30024       };
30025     } catch (std::exception& e) {
30026       {
30027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30028       };
30029     } catch (Dali::DaliException e) {
30030       {
30031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30032       };
30033     } catch (...) {
30034       {
30035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30036       };
30037     }
30038   }
30039
30040   jresult = new Dali::Degree((const Dali::Degree &)result);
30041   return jresult;
30042 }
30043
30044
30045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30046   int jresult ;
30047   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30048   std::size_t arg2 ;
30049   Dali::MouseButton::Type result;
30050
30051   arg1 = (Dali::TouchData *)jarg1;
30052   arg2 = (std::size_t)jarg2;
30053   {
30054     try {
30055       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30056     } catch (std::out_of_range& e) {
30057       {
30058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30059       };
30060     } catch (std::exception& e) {
30061       {
30062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30063       };
30064     } catch (Dali::DaliException e) {
30065       {
30066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30067       };
30068     } catch (...) {
30069       {
30070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30071       };
30072     }
30073   }
30074
30075   jresult = static_cast< int >(result);
30076   return jresult;
30077 }
30078
30079
30080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30081   void * jresult ;
30082   Dali::GestureDetector *result = 0 ;
30083
30084   {
30085     try {
30086       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30087     } catch (std::out_of_range& e) {
30088       {
30089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30090       };
30091     } catch (std::exception& e) {
30092       {
30093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30094       };
30095     } catch (Dali::DaliException e) {
30096       {
30097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30098       };
30099     } catch (...) {
30100       {
30101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30102       };
30103     }
30104   }
30105
30106   jresult = (void *)result;
30107   return jresult;
30108 }
30109
30110
30111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30112   void * jresult ;
30113   Dali::BaseHandle arg1 ;
30114   Dali::BaseHandle *argp1 ;
30115   Dali::GestureDetector result;
30116
30117   argp1 = (Dali::BaseHandle *)jarg1;
30118   if (!argp1) {
30119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30120     return 0;
30121   }
30122   arg1 = *argp1;
30123   {
30124     try {
30125       result = Dali::GestureDetector::DownCast(arg1);
30126     } catch (std::out_of_range& e) {
30127       {
30128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30129       };
30130     } catch (std::exception& e) {
30131       {
30132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30133       };
30134     } catch (Dali::DaliException e) {
30135       {
30136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30137       };
30138     } catch (...) {
30139       {
30140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30141       };
30142     }
30143   }
30144
30145   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30146   return jresult;
30147 }
30148
30149
30150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30151   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30152
30153   arg1 = (Dali::GestureDetector *)jarg1;
30154   {
30155     try {
30156       delete arg1;
30157     } catch (std::out_of_range& e) {
30158       {
30159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30160       };
30161     } catch (std::exception& e) {
30162       {
30163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30164       };
30165     } catch (Dali::DaliException e) {
30166       {
30167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30168       };
30169     } catch (...) {
30170       {
30171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30172       };
30173     }
30174   }
30175
30176 }
30177
30178
30179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30180   void * jresult ;
30181   Dali::GestureDetector *arg1 = 0 ;
30182   Dali::GestureDetector *result = 0 ;
30183
30184   arg1 = (Dali::GestureDetector *)jarg1;
30185   if (!arg1) {
30186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30187     return 0;
30188   }
30189   {
30190     try {
30191       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30192     } catch (std::out_of_range& e) {
30193       {
30194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30195       };
30196     } catch (std::exception& e) {
30197       {
30198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30199       };
30200     } catch (Dali::DaliException e) {
30201       {
30202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30203       };
30204     } catch (...) {
30205       {
30206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30207       };
30208     }
30209   }
30210
30211   jresult = (void *)result;
30212   return jresult;
30213 }
30214
30215
30216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30217   void * jresult ;
30218   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30219   Dali::GestureDetector *arg2 = 0 ;
30220   Dali::GestureDetector *result = 0 ;
30221
30222   arg1 = (Dali::GestureDetector *)jarg1;
30223   arg2 = (Dali::GestureDetector *)jarg2;
30224   if (!arg2) {
30225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30226     return 0;
30227   }
30228   {
30229     try {
30230       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30231     } catch (std::out_of_range& e) {
30232       {
30233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30234       };
30235     } catch (std::exception& e) {
30236       {
30237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30238       };
30239     } catch (Dali::DaliException e) {
30240       {
30241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30242       };
30243     } catch (...) {
30244       {
30245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30246       };
30247     }
30248   }
30249
30250   jresult = (void *)result;
30251   return jresult;
30252 }
30253
30254
30255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30256   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30257   Dali::Actor arg2 ;
30258   Dali::Actor *argp2 ;
30259
30260   arg1 = (Dali::GestureDetector *)jarg1;
30261   argp2 = (Dali::Actor *)jarg2;
30262   if (!argp2) {
30263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30264     return ;
30265   }
30266   arg2 = *argp2;
30267   {
30268     try {
30269       (arg1)->Attach(arg2);
30270     } catch (std::out_of_range& e) {
30271       {
30272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30273       };
30274     } catch (std::exception& e) {
30275       {
30276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30277       };
30278     } catch (Dali::DaliException e) {
30279       {
30280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30281       };
30282     } catch (...) {
30283       {
30284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30285       };
30286     }
30287   }
30288
30289 }
30290
30291
30292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30293   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30294   Dali::Actor arg2 ;
30295   Dali::Actor *argp2 ;
30296
30297   arg1 = (Dali::GestureDetector *)jarg1;
30298   argp2 = (Dali::Actor *)jarg2;
30299   if (!argp2) {
30300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30301     return ;
30302   }
30303   arg2 = *argp2;
30304   {
30305     try {
30306       (arg1)->Detach(arg2);
30307     } catch (std::out_of_range& e) {
30308       {
30309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30310       };
30311     } catch (std::exception& e) {
30312       {
30313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30314       };
30315     } catch (Dali::DaliException e) {
30316       {
30317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30318       };
30319     } catch (...) {
30320       {
30321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30322       };
30323     }
30324   }
30325
30326 }
30327
30328
30329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30330   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30331
30332   arg1 = (Dali::GestureDetector *)jarg1;
30333   {
30334     try {
30335       (arg1)->DetachAll();
30336     } catch (std::out_of_range& e) {
30337       {
30338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30339       };
30340     } catch (std::exception& e) {
30341       {
30342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30343       };
30344     } catch (Dali::DaliException e) {
30345       {
30346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30347       };
30348     } catch (...) {
30349       {
30350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30351       };
30352     }
30353   }
30354
30355 }
30356
30357
30358 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30359   unsigned long jresult ;
30360   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30361   size_t result;
30362
30363   arg1 = (Dali::GestureDetector *)jarg1;
30364   {
30365     try {
30366       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30367     } catch (std::out_of_range& e) {
30368       {
30369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30370       };
30371     } catch (std::exception& e) {
30372       {
30373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30374       };
30375     } catch (Dali::DaliException e) {
30376       {
30377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30378       };
30379     } catch (...) {
30380       {
30381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30382       };
30383     }
30384   }
30385
30386   jresult = (unsigned long)result;
30387   return jresult;
30388 }
30389
30390
30391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30392   void * jresult ;
30393   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30394   size_t arg2 ;
30395   Dali::Actor result;
30396
30397   arg1 = (Dali::GestureDetector *)jarg1;
30398   arg2 = (size_t)jarg2;
30399   {
30400     try {
30401       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30402     } catch (std::out_of_range& e) {
30403       {
30404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30405       };
30406     } catch (std::exception& e) {
30407       {
30408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30409       };
30410     } catch (Dali::DaliException e) {
30411       {
30412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30413       };
30414     } catch (...) {
30415       {
30416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30417       };
30418     }
30419   }
30420
30421   jresult = new Dali::Actor((const Dali::Actor &)result);
30422   return jresult;
30423 }
30424
30425
30426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30427   void * jresult ;
30428   Dali::Gesture *arg1 = 0 ;
30429   Dali::Gesture *result = 0 ;
30430
30431   arg1 = (Dali::Gesture *)jarg1;
30432   if (!arg1) {
30433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30434     return 0;
30435   }
30436   {
30437     try {
30438       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30439     } catch (std::out_of_range& e) {
30440       {
30441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30442       };
30443     } catch (std::exception& e) {
30444       {
30445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30446       };
30447     } catch (Dali::DaliException e) {
30448       {
30449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30450       };
30451     } catch (...) {
30452       {
30453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30454       };
30455     }
30456   }
30457
30458   jresult = (void *)result;
30459   return jresult;
30460 }
30461
30462
30463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30464   void * jresult ;
30465   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30466   Dali::Gesture *arg2 = 0 ;
30467   Dali::Gesture *result = 0 ;
30468
30469   arg1 = (Dali::Gesture *)jarg1;
30470   arg2 = (Dali::Gesture *)jarg2;
30471   if (!arg2) {
30472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30473     return 0;
30474   }
30475   {
30476     try {
30477       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30478     } catch (std::out_of_range& e) {
30479       {
30480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30481       };
30482     } catch (std::exception& e) {
30483       {
30484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30485       };
30486     } catch (Dali::DaliException e) {
30487       {
30488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30489       };
30490     } catch (...) {
30491       {
30492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30493       };
30494     }
30495   }
30496
30497   jresult = (void *)result;
30498   return jresult;
30499 }
30500
30501
30502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30503   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30504
30505   arg1 = (Dali::Gesture *)jarg1;
30506   {
30507     try {
30508       delete arg1;
30509     } catch (std::out_of_range& e) {
30510       {
30511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30512       };
30513     } catch (std::exception& e) {
30514       {
30515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30516       };
30517     } catch (Dali::DaliException e) {
30518       {
30519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30520       };
30521     } catch (...) {
30522       {
30523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30524       };
30525     }
30526   }
30527
30528 }
30529
30530
30531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30532   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30533   Dali::Gesture::Type arg2 ;
30534
30535   arg1 = (Dali::Gesture *)jarg1;
30536   arg2 = (Dali::Gesture::Type)jarg2;
30537   if (arg1) (arg1)->type = arg2;
30538 }
30539
30540
30541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30542   int jresult ;
30543   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30544   Dali::Gesture::Type result;
30545
30546   arg1 = (Dali::Gesture *)jarg1;
30547   result = (Dali::Gesture::Type) ((arg1)->type);
30548   jresult = (int)result;
30549   return jresult;
30550 }
30551
30552
30553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30554   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30555   Dali::Gesture::State arg2 ;
30556
30557   arg1 = (Dali::Gesture *)jarg1;
30558   arg2 = (Dali::Gesture::State)jarg2;
30559   if (arg1) (arg1)->state = arg2;
30560 }
30561
30562
30563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30564   int jresult ;
30565   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30566   Dali::Gesture::State result;
30567
30568   arg1 = (Dali::Gesture *)jarg1;
30569   result = (Dali::Gesture::State) ((arg1)->state);
30570   jresult = (int)result;
30571   return jresult;
30572 }
30573
30574
30575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30576   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30577   unsigned int arg2 ;
30578
30579   arg1 = (Dali::Gesture *)jarg1;
30580   arg2 = (unsigned int)jarg2;
30581   if (arg1) (arg1)->time = arg2;
30582 }
30583
30584
30585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30586   unsigned int jresult ;
30587   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30588   unsigned int result;
30589
30590   arg1 = (Dali::Gesture *)jarg1;
30591   result = (unsigned int) ((arg1)->time);
30592   jresult = result;
30593   return jresult;
30594 }
30595
30596
30597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30598   void * jresult ;
30599   Dali::HoverEvent *result = 0 ;
30600
30601   {
30602     try {
30603       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30604     } catch (std::out_of_range& e) {
30605       {
30606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30607       };
30608     } catch (std::exception& e) {
30609       {
30610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30611       };
30612     } catch (Dali::DaliException e) {
30613       {
30614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30615       };
30616     } catch (...) {
30617       {
30618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30619       };
30620     }
30621   }
30622
30623   jresult = (void *)result;
30624   return jresult;
30625 }
30626
30627
30628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30629   void * jresult ;
30630   unsigned long arg1 ;
30631   Dali::HoverEvent *result = 0 ;
30632
30633   arg1 = (unsigned long)jarg1;
30634   {
30635     try {
30636       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30637     } catch (std::out_of_range& e) {
30638       {
30639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30640       };
30641     } catch (std::exception& e) {
30642       {
30643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30644       };
30645     } catch (Dali::DaliException e) {
30646       {
30647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30648       };
30649     } catch (...) {
30650       {
30651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30652       };
30653     }
30654   }
30655
30656   jresult = (void *)result;
30657   return jresult;
30658 }
30659
30660
30661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30662   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30663
30664   arg1 = (Dali::HoverEvent *)jarg1;
30665   {
30666     try {
30667       delete arg1;
30668     } catch (std::out_of_range& e) {
30669       {
30670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30671       };
30672     } catch (std::exception& e) {
30673       {
30674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30675       };
30676     } catch (Dali::DaliException e) {
30677       {
30678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30679       };
30680     } catch (...) {
30681       {
30682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30683       };
30684     }
30685   }
30686
30687 }
30688
30689
30690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30691   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30692   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30693
30694   arg1 = (Dali::HoverEvent *)jarg1;
30695   arg2 = (Dali::TouchPointContainer *)jarg2;
30696   if (arg1) (arg1)->points = *arg2;
30697 }
30698
30699
30700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30701   void * jresult ;
30702   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30703   Dali::TouchPointContainer *result = 0 ;
30704
30705   arg1 = (Dali::HoverEvent *)jarg1;
30706   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30707   jresult = (void *)result;
30708   return jresult;
30709 }
30710
30711
30712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30713   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30714   unsigned long arg2 ;
30715
30716   arg1 = (Dali::HoverEvent *)jarg1;
30717   arg2 = (unsigned long)jarg2;
30718   if (arg1) (arg1)->time = arg2;
30719 }
30720
30721
30722 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30723   unsigned long jresult ;
30724   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30725   unsigned long result;
30726
30727   arg1 = (Dali::HoverEvent *)jarg1;
30728   result = (unsigned long) ((arg1)->time);
30729   jresult = (unsigned long)result;
30730   return jresult;
30731 }
30732
30733
30734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30735   unsigned int jresult ;
30736   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30737   unsigned int result;
30738
30739   arg1 = (Dali::HoverEvent *)jarg1;
30740   {
30741     try {
30742       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30743     } catch (std::out_of_range& e) {
30744       {
30745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30746       };
30747     } catch (std::exception& e) {
30748       {
30749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30750       };
30751     } catch (Dali::DaliException e) {
30752       {
30753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30754       };
30755     } catch (...) {
30756       {
30757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30758       };
30759     }
30760   }
30761
30762   jresult = result;
30763   return jresult;
30764 }
30765
30766
30767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30768   void * jresult ;
30769   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30770   unsigned int arg2 ;
30771   Dali::TouchPoint *result = 0 ;
30772
30773   arg1 = (Dali::HoverEvent *)jarg1;
30774   arg2 = (unsigned int)jarg2;
30775   {
30776     try {
30777       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30778     } catch (std::out_of_range& e) {
30779       {
30780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30781       };
30782     } catch (std::exception& e) {
30783       {
30784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30785       };
30786     } catch (Dali::DaliException e) {
30787       {
30788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30789       };
30790     } catch (...) {
30791       {
30792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30793       };
30794     }
30795   }
30796
30797   jresult = (void *)result;
30798   return jresult;
30799 }
30800
30801
30802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30803   void * jresult ;
30804   Dali::KeyEvent *result = 0 ;
30805
30806   {
30807     try {
30808       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30809     } catch (std::out_of_range& e) {
30810       {
30811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30812       };
30813     } catch (std::exception& e) {
30814       {
30815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30816       };
30817     } catch (Dali::DaliException e) {
30818       {
30819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30820       };
30821     } catch (...) {
30822       {
30823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30824       };
30825     }
30826   }
30827
30828   jresult = (void *)result;
30829   return jresult;
30830 }
30831
30832
30833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30834   void * jresult ;
30835   std::string *arg1 = 0 ;
30836   std::string *arg2 = 0 ;
30837   int arg3 ;
30838   int arg4 ;
30839   unsigned long arg5 ;
30840   Dali::KeyEvent::State *arg6 = 0 ;
30841   Dali::KeyEvent::State temp6 ;
30842   Dali::KeyEvent *result = 0 ;
30843
30844   if (!jarg1) {
30845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30846     return 0;
30847   }
30848   std::string arg1_str(jarg1);
30849   arg1 = &arg1_str;
30850   if (!jarg2) {
30851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30852     return 0;
30853   }
30854   std::string arg2_str(jarg2);
30855   arg2 = &arg2_str;
30856   arg3 = (int)jarg3;
30857   arg4 = (int)jarg4;
30858   arg5 = (unsigned long)jarg5;
30859   temp6 = (Dali::KeyEvent::State)jarg6;
30860   arg6 = &temp6;
30861   {
30862     try {
30863       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30864     } catch (std::out_of_range& e) {
30865       {
30866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30867       };
30868     } catch (std::exception& e) {
30869       {
30870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30871       };
30872     } catch (Dali::DaliException e) {
30873       {
30874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30875       };
30876     } catch (...) {
30877       {
30878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30879       };
30880     }
30881   }
30882
30883   jresult = (void *)result;
30884
30885   //argout typemap for const std::string&
30886
30887
30888   //argout typemap for const std::string&
30889
30890   return jresult;
30891 }
30892
30893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30894   void * jresult ;
30895   Dali::KeyEvent *arg1 = 0 ;
30896   Dali::KeyEvent *result = 0 ;
30897
30898   arg1 = (Dali::KeyEvent *)jarg1;
30899   if (!arg1) {
30900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30901     return 0;
30902   }
30903   {
30904     try {
30905       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30906     } catch (std::out_of_range& e) {
30907       {
30908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30909       };
30910     } catch (std::exception& e) {
30911       {
30912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30913       };
30914     } catch (Dali::DaliException e) {
30915       {
30916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30917       };
30918     } catch (...) {
30919       {
30920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30921       };
30922     }
30923   }
30924
30925   jresult = (void *)result;
30926   return jresult;
30927 }
30928
30929
30930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30931   void * jresult ;
30932   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30933   Dali::KeyEvent *arg2 = 0 ;
30934   Dali::KeyEvent *result = 0 ;
30935
30936   arg1 = (Dali::KeyEvent *)jarg1;
30937   arg2 = (Dali::KeyEvent *)jarg2;
30938   if (!arg2) {
30939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30940     return 0;
30941   }
30942   {
30943     try {
30944       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
30945     } catch (std::out_of_range& e) {
30946       {
30947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30948       };
30949     } catch (std::exception& e) {
30950       {
30951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30952       };
30953     } catch (Dali::DaliException e) {
30954       {
30955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30956       };
30957     } catch (...) {
30958       {
30959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30960       };
30961     }
30962   }
30963
30964   jresult = (void *)result;
30965   return jresult;
30966 }
30967
30968
30969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
30970   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30971
30972   arg1 = (Dali::KeyEvent *)jarg1;
30973   {
30974     try {
30975       delete arg1;
30976     } catch (std::out_of_range& e) {
30977       {
30978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30979       };
30980     } catch (std::exception& e) {
30981       {
30982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30983       };
30984     } catch (Dali::DaliException e) {
30985       {
30986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30987       };
30988     } catch (...) {
30989       {
30990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30991       };
30992     }
30993   }
30994
30995 }
30996
30997
30998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
30999   unsigned int jresult ;
31000   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31001   bool result;
31002
31003   arg1 = (Dali::KeyEvent *)jarg1;
31004   {
31005     try {
31006       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31007     } catch (std::out_of_range& e) {
31008       {
31009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31010       };
31011     } catch (std::exception& e) {
31012       {
31013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31014       };
31015     } catch (Dali::DaliException e) {
31016       {
31017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31018       };
31019     } catch (...) {
31020       {
31021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31022       };
31023     }
31024   }
31025
31026   jresult = result;
31027   return jresult;
31028 }
31029
31030
31031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31032   unsigned int jresult ;
31033   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31034   bool result;
31035
31036   arg1 = (Dali::KeyEvent *)jarg1;
31037   {
31038     try {
31039       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31040     } catch (std::out_of_range& e) {
31041       {
31042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31043       };
31044     } catch (std::exception& e) {
31045       {
31046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31047       };
31048     } catch (Dali::DaliException e) {
31049       {
31050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31051       };
31052     } catch (...) {
31053       {
31054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31055       };
31056     }
31057   }
31058
31059   jresult = result;
31060   return jresult;
31061 }
31062
31063
31064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31065   unsigned int jresult ;
31066   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31067   bool result;
31068
31069   arg1 = (Dali::KeyEvent *)jarg1;
31070   {
31071     try {
31072       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31073     } catch (std::out_of_range& e) {
31074       {
31075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31076       };
31077     } catch (std::exception& e) {
31078       {
31079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31080       };
31081     } catch (Dali::DaliException e) {
31082       {
31083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31084       };
31085     } catch (...) {
31086       {
31087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31088       };
31089     }
31090   }
31091
31092   jresult = result;
31093   return jresult;
31094 }
31095
31096
31097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31098   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31099   std::string *arg2 = 0 ;
31100
31101   arg1 = (Dali::KeyEvent *)jarg1;
31102   if (!jarg2) {
31103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31104     return ;
31105   }
31106   std::string arg2_str(jarg2);
31107   arg2 = &arg2_str;
31108   if (arg1) (arg1)->keyPressedName = *arg2;
31109
31110   //argout typemap for const std::string&
31111
31112 }
31113
31114
31115 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31116   char * jresult ;
31117
31118   if( jarg1 == NULL )
31119   {
31120     jresult = SWIG_csharp_string_callback( "" );
31121   }
31122   else
31123   {
31124     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31125     std::string *result = 0;
31126
31127     arg1 = ( Dali::KeyEvent * )jarg1;
31128     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31129     jresult = SWIG_csharp_string_callback( result->c_str() );
31130   }
31131
31132   return jresult;
31133 }
31134
31135
31136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31137   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31138   std::string *arg2 = 0 ;
31139
31140   arg1 = (Dali::KeyEvent *)jarg1;
31141   if (!jarg2) {
31142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31143     return ;
31144   }
31145   std::string arg2_str(jarg2);
31146   arg2 = &arg2_str;
31147   if (arg1) (arg1)->keyPressed = *arg2;
31148
31149   //argout typemap for const std::string&
31150
31151 }
31152
31153
31154 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31155   char * jresult ;
31156   if( NULL == jarg1 )
31157   {
31158     jresult = SWIG_csharp_string_callback( "" );
31159   }
31160   else
31161   {
31162     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31163     std::string *result = 0;
31164
31165     arg1 = ( Dali::KeyEvent * )jarg1;
31166     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31167     jresult = SWIG_csharp_string_callback( result->c_str() );
31168   }
31169   return jresult;
31170 }
31171
31172
31173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31174   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31175   int arg2 ;
31176
31177   arg1 = (Dali::KeyEvent *)jarg1;
31178   arg2 = (int)jarg2;
31179   if (arg1) (arg1)->keyCode = arg2;
31180 }
31181
31182
31183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31184   int jresult ;
31185   if( NULL == jarg1 )
31186   {
31187     jresult = -1;
31188   }
31189   else
31190   {
31191     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31192     int result;
31193
31194     arg1 = ( Dali::KeyEvent * )jarg1;
31195     result = (int)( ( arg1 )->keyCode );
31196     jresult = result;
31197   }
31198   return jresult;
31199 }
31200
31201
31202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31203   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31204   int arg2 ;
31205
31206   arg1 = (Dali::KeyEvent *)jarg1;
31207   arg2 = (int)jarg2;
31208   if (arg1) (arg1)->keyModifier = arg2;
31209 }
31210
31211
31212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31213   int jresult ;
31214   if( jarg1 == NULL )
31215   {
31216     jresult = -1;
31217   }
31218   else
31219   {
31220     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31221     int result;
31222
31223     arg1 = ( Dali::KeyEvent * )jarg1;
31224     result = (int)( ( arg1 )->keyModifier );
31225     jresult = result;
31226   }
31227   return jresult;
31228 }
31229
31230
31231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31232   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31233   unsigned long arg2 ;
31234
31235   arg1 = (Dali::KeyEvent *)jarg1;
31236   arg2 = (unsigned long)jarg2;
31237   if (arg1) (arg1)->time = arg2;
31238 }
31239
31240
31241 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31242   unsigned long jresult ;
31243   if( jarg1 == NULL )
31244   {
31245     jresult = 0;
31246   }
31247   else
31248   {
31249     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31250     unsigned long result;
31251
31252     arg1 = ( Dali::KeyEvent * )jarg1;
31253     result = (unsigned long)( ( arg1 )->time );
31254     jresult = (unsigned long)result;
31255   }
31256   return jresult;
31257 }
31258
31259
31260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31261   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31262   Dali::KeyEvent::State arg2 ;
31263
31264   arg1 = (Dali::KeyEvent *)jarg1;
31265   arg2 = (Dali::KeyEvent::State)jarg2;
31266   if (arg1) (arg1)->state = arg2;
31267 }
31268
31269
31270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31271   int jresult ;
31272   if( jarg1 == NULL )
31273   {
31274     jresult = -1;
31275   }
31276   else
31277   {
31278     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31279     Dali::KeyEvent::State result;
31280
31281     arg1 = ( Dali::KeyEvent * )jarg1;
31282     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31283     jresult = (int)result;
31284   }
31285   return jresult;
31286 }
31287
31288 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31289   char * jresult ;
31290   std::string result;
31291   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31292
31293   arg1 = (Dali::KeyEvent *)jarg1;
31294   if (!arg1) {
31295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31296     return 0;
31297   }
31298   {
31299     try {
31300       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31301     } catch (std::out_of_range& e) {
31302       {
31303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31304       };
31305     } catch (std::exception& e) {
31306       {
31307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31308       };
31309     } catch (Dali::DaliException e) {
31310       {
31311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31312       };
31313     } catch (...) {
31314       {
31315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31316       };
31317     }
31318
31319   }
31320
31321   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31322   return jresult;
31323 }
31324
31325
31326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31327   void * jresult ;
31328   Dali::LongPressGestureDetector *result = 0 ;
31329
31330   {
31331     try {
31332       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31333     } catch (std::out_of_range& e) {
31334       {
31335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31336       };
31337     } catch (std::exception& e) {
31338       {
31339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31340       };
31341     } catch (Dali::DaliException e) {
31342       {
31343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31344       };
31345     } catch (...) {
31346       {
31347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31348       };
31349     }
31350   }
31351
31352   jresult = (void *)result;
31353   return jresult;
31354 }
31355
31356
31357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31358   void * jresult ;
31359   Dali::LongPressGestureDetector result;
31360
31361   {
31362     try {
31363       result = Dali::LongPressGestureDetector::New();
31364     } catch (std::out_of_range& e) {
31365       {
31366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31367       };
31368     } catch (std::exception& e) {
31369       {
31370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31371       };
31372     } catch (Dali::DaliException e) {
31373       {
31374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31375       };
31376     } catch (...) {
31377       {
31378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31379       };
31380     }
31381   }
31382
31383   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31384   return jresult;
31385 }
31386
31387
31388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31389   void * jresult ;
31390   unsigned int arg1 ;
31391   Dali::LongPressGestureDetector result;
31392
31393   arg1 = (unsigned int)jarg1;
31394   {
31395     try {
31396       result = Dali::LongPressGestureDetector::New(arg1);
31397     } catch (std::out_of_range& e) {
31398       {
31399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31400       };
31401     } catch (std::exception& e) {
31402       {
31403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31404       };
31405     } catch (Dali::DaliException e) {
31406       {
31407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31408       };
31409     } catch (...) {
31410       {
31411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31412       };
31413     }
31414   }
31415
31416   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31417   return jresult;
31418 }
31419
31420
31421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31422   void * jresult ;
31423   unsigned int arg1 ;
31424   unsigned int arg2 ;
31425   Dali::LongPressGestureDetector result;
31426
31427   arg1 = (unsigned int)jarg1;
31428   arg2 = (unsigned int)jarg2;
31429   {
31430     try {
31431       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31432     } catch (std::out_of_range& e) {
31433       {
31434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31435       };
31436     } catch (std::exception& e) {
31437       {
31438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31439       };
31440     } catch (Dali::DaliException e) {
31441       {
31442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31443       };
31444     } catch (...) {
31445       {
31446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31447       };
31448     }
31449   }
31450
31451   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31452   return jresult;
31453 }
31454
31455
31456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31457   void * jresult ;
31458   Dali::BaseHandle arg1 ;
31459   Dali::BaseHandle *argp1 ;
31460   Dali::LongPressGestureDetector result;
31461
31462   argp1 = (Dali::BaseHandle *)jarg1;
31463   if (!argp1) {
31464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31465     return 0;
31466   }
31467   arg1 = *argp1;
31468   {
31469     try {
31470       result = Dali::LongPressGestureDetector::DownCast(arg1);
31471     } catch (std::out_of_range& e) {
31472       {
31473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31474       };
31475     } catch (std::exception& e) {
31476       {
31477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31478       };
31479     } catch (Dali::DaliException e) {
31480       {
31481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31482       };
31483     } catch (...) {
31484       {
31485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31486       };
31487     }
31488   }
31489
31490   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31491   return jresult;
31492 }
31493
31494
31495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31496   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31497
31498   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31499   {
31500     try {
31501       delete arg1;
31502     } catch (std::out_of_range& e) {
31503       {
31504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31505       };
31506     } catch (std::exception& e) {
31507       {
31508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31509       };
31510     } catch (Dali::DaliException e) {
31511       {
31512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31513       };
31514     } catch (...) {
31515       {
31516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31517       };
31518     }
31519   }
31520
31521 }
31522
31523
31524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31525   void * jresult ;
31526   Dali::LongPressGestureDetector *arg1 = 0 ;
31527   Dali::LongPressGestureDetector *result = 0 ;
31528
31529   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31530   if (!arg1) {
31531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31532     return 0;
31533   }
31534   {
31535     try {
31536       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31537     } catch (std::out_of_range& e) {
31538       {
31539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31540       };
31541     } catch (std::exception& e) {
31542       {
31543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31544       };
31545     } catch (Dali::DaliException e) {
31546       {
31547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31548       };
31549     } catch (...) {
31550       {
31551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31552       };
31553     }
31554   }
31555
31556   jresult = (void *)result;
31557   return jresult;
31558 }
31559
31560
31561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31562   void * jresult ;
31563   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31564   Dali::LongPressGestureDetector *arg2 = 0 ;
31565   Dali::LongPressGestureDetector *result = 0 ;
31566
31567   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31568   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31569   if (!arg2) {
31570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31571     return 0;
31572   }
31573   {
31574     try {
31575       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31576     } catch (std::out_of_range& e) {
31577       {
31578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31579       };
31580     } catch (std::exception& e) {
31581       {
31582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31583       };
31584     } catch (Dali::DaliException e) {
31585       {
31586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31587       };
31588     } catch (...) {
31589       {
31590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31591       };
31592     }
31593   }
31594
31595   jresult = (void *)result;
31596   return jresult;
31597 }
31598
31599
31600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31601   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31602   unsigned int arg2 ;
31603
31604   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31605   arg2 = (unsigned int)jarg2;
31606   {
31607     try {
31608       (arg1)->SetTouchesRequired(arg2);
31609     } catch (std::out_of_range& e) {
31610       {
31611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31612       };
31613     } catch (std::exception& e) {
31614       {
31615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31616       };
31617     } catch (Dali::DaliException e) {
31618       {
31619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31620       };
31621     } catch (...) {
31622       {
31623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31624       };
31625     }
31626   }
31627
31628 }
31629
31630
31631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31632   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31633   unsigned int arg2 ;
31634   unsigned int arg3 ;
31635
31636   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31637   arg2 = (unsigned int)jarg2;
31638   arg3 = (unsigned int)jarg3;
31639   {
31640     try {
31641       (arg1)->SetTouchesRequired(arg2,arg3);
31642     } catch (std::out_of_range& e) {
31643       {
31644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31645       };
31646     } catch (std::exception& e) {
31647       {
31648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31649       };
31650     } catch (Dali::DaliException e) {
31651       {
31652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31653       };
31654     } catch (...) {
31655       {
31656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31657       };
31658     }
31659   }
31660
31661 }
31662
31663
31664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31665   unsigned int jresult ;
31666   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31667   unsigned int result;
31668
31669   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31670   {
31671     try {
31672       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31673     } catch (std::out_of_range& e) {
31674       {
31675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31676       };
31677     } catch (std::exception& e) {
31678       {
31679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31680       };
31681     } catch (Dali::DaliException e) {
31682       {
31683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31684       };
31685     } catch (...) {
31686       {
31687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31688       };
31689     }
31690   }
31691
31692   jresult = result;
31693   return jresult;
31694 }
31695
31696
31697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31698   unsigned int jresult ;
31699   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31700   unsigned int result;
31701
31702   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31703   {
31704     try {
31705       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31706     } catch (std::out_of_range& e) {
31707       {
31708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31709       };
31710     } catch (std::exception& e) {
31711       {
31712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31713       };
31714     } catch (Dali::DaliException e) {
31715       {
31716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31717       };
31718     } catch (...) {
31719       {
31720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31721       };
31722     }
31723   }
31724
31725   jresult = result;
31726   return jresult;
31727 }
31728
31729
31730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31731   void * jresult ;
31732   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31733   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31734
31735   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31736   {
31737     try {
31738       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31739     } catch (std::out_of_range& e) {
31740       {
31741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31742       };
31743     } catch (std::exception& e) {
31744       {
31745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31746       };
31747     } catch (Dali::DaliException e) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31750       };
31751     } catch (...) {
31752       {
31753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31754       };
31755     }
31756   }
31757
31758   jresult = (void *)result;
31759   return jresult;
31760 }
31761
31762
31763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31764   void * jresult ;
31765   Dali::Gesture::State arg1 ;
31766   Dali::LongPressGesture *result = 0 ;
31767
31768   arg1 = (Dali::Gesture::State)jarg1;
31769   {
31770     try {
31771       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31772     } catch (std::out_of_range& e) {
31773       {
31774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31775       };
31776     } catch (std::exception& e) {
31777       {
31778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31779       };
31780     } catch (Dali::DaliException e) {
31781       {
31782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31783       };
31784     } catch (...) {
31785       {
31786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31787       };
31788     }
31789   }
31790
31791   jresult = (void *)result;
31792   return jresult;
31793 }
31794
31795
31796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31797   void * jresult ;
31798   Dali::LongPressGesture *arg1 = 0 ;
31799   Dali::LongPressGesture *result = 0 ;
31800
31801   arg1 = (Dali::LongPressGesture *)jarg1;
31802   if (!arg1) {
31803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31804     return 0;
31805   }
31806   {
31807     try {
31808       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31809     } catch (std::out_of_range& e) {
31810       {
31811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31812       };
31813     } catch (std::exception& e) {
31814       {
31815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31816       };
31817     } catch (Dali::DaliException e) {
31818       {
31819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31820       };
31821     } catch (...) {
31822       {
31823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31824       };
31825     }
31826   }
31827
31828   jresult = (void *)result;
31829   return jresult;
31830 }
31831
31832
31833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31834   void * jresult ;
31835   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31836   Dali::LongPressGesture *arg2 = 0 ;
31837   Dali::LongPressGesture *result = 0 ;
31838
31839   arg1 = (Dali::LongPressGesture *)jarg1;
31840   arg2 = (Dali::LongPressGesture *)jarg2;
31841   if (!arg2) {
31842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31843     return 0;
31844   }
31845   {
31846     try {
31847       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31848     } catch (std::out_of_range& e) {
31849       {
31850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31851       };
31852     } catch (std::exception& e) {
31853       {
31854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31855       };
31856     } catch (Dali::DaliException e) {
31857       {
31858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31859       };
31860     } catch (...) {
31861       {
31862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31863       };
31864     }
31865   }
31866
31867   jresult = (void *)result;
31868   return jresult;
31869 }
31870
31871
31872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31873   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31874
31875   arg1 = (Dali::LongPressGesture *)jarg1;
31876   {
31877     try {
31878       delete arg1;
31879     } catch (std::out_of_range& e) {
31880       {
31881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31882       };
31883     } catch (std::exception& e) {
31884       {
31885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31886       };
31887     } catch (Dali::DaliException e) {
31888       {
31889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31890       };
31891     } catch (...) {
31892       {
31893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31894       };
31895     }
31896   }
31897
31898 }
31899
31900
31901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31902   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31903   unsigned int arg2 ;
31904
31905   arg1 = (Dali::LongPressGesture *)jarg1;
31906   arg2 = (unsigned int)jarg2;
31907   if (arg1) (arg1)->numberOfTouches = arg2;
31908 }
31909
31910
31911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31912   unsigned int jresult ;
31913   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31914   unsigned int result;
31915
31916   arg1 = (Dali::LongPressGesture *)jarg1;
31917   result = (unsigned int) ((arg1)->numberOfTouches);
31918   jresult = result;
31919   return jresult;
31920 }
31921
31922
31923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31924   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31925   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31926
31927   arg1 = (Dali::LongPressGesture *)jarg1;
31928   arg2 = (Dali::Vector2 *)jarg2;
31929   if (arg1) (arg1)->screenPoint = *arg2;
31930 }
31931
31932
31933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31934   void * jresult ;
31935   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31936   Dali::Vector2 *result = 0 ;
31937
31938   arg1 = (Dali::LongPressGesture *)jarg1;
31939   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
31940   jresult = (void *)result;
31941   return jresult;
31942 }
31943
31944
31945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
31946   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31947   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31948
31949   arg1 = (Dali::LongPressGesture *)jarg1;
31950   arg2 = (Dali::Vector2 *)jarg2;
31951   if (arg1) (arg1)->localPoint = *arg2;
31952 }
31953
31954
31955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
31956   void * jresult ;
31957   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31958   Dali::Vector2 *result = 0 ;
31959
31960   arg1 = (Dali::LongPressGesture *)jarg1;
31961   result = (Dali::Vector2 *)& ((arg1)->localPoint);
31962   jresult = (void *)result;
31963   return jresult;
31964 }
31965
31966
31967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
31968   void * jresult ;
31969   Dali::WheelEvent *result = 0 ;
31970
31971   {
31972     try {
31973       result = (Dali::WheelEvent *)new Dali::WheelEvent();
31974     } catch (std::out_of_range& e) {
31975       {
31976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31977       };
31978     } catch (std::exception& e) {
31979       {
31980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31981       };
31982     } catch (Dali::DaliException e) {
31983       {
31984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31985       };
31986     } catch (...) {
31987       {
31988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31989       };
31990     }
31991   }
31992
31993   jresult = (void *)result;
31994   return jresult;
31995 }
31996
31997
31998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
31999   void * jresult ;
32000   Dali::WheelEvent::Type arg1 ;
32001   int arg2 ;
32002   unsigned int arg3 ;
32003   Dali::Vector2 arg4 ;
32004   int arg5 ;
32005   unsigned int arg6 ;
32006   Dali::Vector2 *argp4 ;
32007   Dali::WheelEvent *result = 0 ;
32008
32009   arg1 = (Dali::WheelEvent::Type)jarg1;
32010   arg2 = (int)jarg2;
32011   arg3 = (unsigned int)jarg3;
32012   argp4 = (Dali::Vector2 *)jarg4;
32013   if (!argp4) {
32014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32015     return 0;
32016   }
32017   arg4 = *argp4;
32018   arg5 = (int)jarg5;
32019   arg6 = (unsigned int)jarg6;
32020   {
32021     try {
32022       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32023     } catch (std::out_of_range& e) {
32024       {
32025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32026       };
32027     } catch (std::exception& e) {
32028       {
32029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32030       };
32031     } catch (Dali::DaliException e) {
32032       {
32033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32034       };
32035     } catch (...) {
32036       {
32037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32038       };
32039     }
32040   }
32041
32042   jresult = (void *)result;
32043   return jresult;
32044 }
32045
32046
32047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32048   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32049
32050   arg1 = (Dali::WheelEvent *)jarg1;
32051   {
32052     try {
32053       delete arg1;
32054     } catch (std::out_of_range& e) {
32055       {
32056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32057       };
32058     } catch (std::exception& e) {
32059       {
32060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32061       };
32062     } catch (Dali::DaliException e) {
32063       {
32064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32065       };
32066     } catch (...) {
32067       {
32068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32069       };
32070     }
32071   }
32072
32073 }
32074
32075
32076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32077   unsigned int jresult ;
32078   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32079   bool result;
32080
32081   arg1 = (Dali::WheelEvent *)jarg1;
32082   {
32083     try {
32084       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32085     } catch (std::out_of_range& e) {
32086       {
32087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32088       };
32089     } catch (std::exception& e) {
32090       {
32091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32092       };
32093     } catch (Dali::DaliException e) {
32094       {
32095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32096       };
32097     } catch (...) {
32098       {
32099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32100       };
32101     }
32102   }
32103
32104   jresult = result;
32105   return jresult;
32106 }
32107
32108
32109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32110   unsigned int jresult ;
32111   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32112   bool result;
32113
32114   arg1 = (Dali::WheelEvent *)jarg1;
32115   {
32116     try {
32117       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32118     } catch (std::out_of_range& e) {
32119       {
32120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32121       };
32122     } catch (std::exception& e) {
32123       {
32124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32125       };
32126     } catch (Dali::DaliException e) {
32127       {
32128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32129       };
32130     } catch (...) {
32131       {
32132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32133       };
32134     }
32135   }
32136
32137   jresult = result;
32138   return jresult;
32139 }
32140
32141
32142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32143   unsigned int jresult ;
32144   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32145   bool result;
32146
32147   arg1 = (Dali::WheelEvent *)jarg1;
32148   {
32149     try {
32150       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32151     } catch (std::out_of_range& e) {
32152       {
32153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32154       };
32155     } catch (std::exception& e) {
32156       {
32157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32158       };
32159     } catch (Dali::DaliException e) {
32160       {
32161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32162       };
32163     } catch (...) {
32164       {
32165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32166       };
32167     }
32168   }
32169
32170   jresult = result;
32171   return jresult;
32172 }
32173
32174
32175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32176   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32177   Dali::WheelEvent::Type arg2 ;
32178
32179   arg1 = (Dali::WheelEvent *)jarg1;
32180   arg2 = (Dali::WheelEvent::Type)jarg2;
32181   if (arg1) (arg1)->type = arg2;
32182 }
32183
32184
32185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32186   int jresult ;
32187   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32188   Dali::WheelEvent::Type result;
32189
32190   arg1 = (Dali::WheelEvent *)jarg1;
32191   result = (Dali::WheelEvent::Type) ((arg1)->type);
32192   jresult = (int)result;
32193   return jresult;
32194 }
32195
32196
32197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32198   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32199   int arg2 ;
32200
32201   arg1 = (Dali::WheelEvent *)jarg1;
32202   arg2 = (int)jarg2;
32203   if (arg1) (arg1)->direction = arg2;
32204 }
32205
32206
32207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32208   int jresult ;
32209   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32210   int result;
32211
32212   arg1 = (Dali::WheelEvent *)jarg1;
32213   result = (int) ((arg1)->direction);
32214   jresult = result;
32215   return jresult;
32216 }
32217
32218
32219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32220   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32221   unsigned int arg2 ;
32222
32223   arg1 = (Dali::WheelEvent *)jarg1;
32224   arg2 = (unsigned int)jarg2;
32225   if (arg1) (arg1)->modifiers = arg2;
32226 }
32227
32228
32229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32230   unsigned int jresult ;
32231   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32232   unsigned int result;
32233
32234   arg1 = (Dali::WheelEvent *)jarg1;
32235   result = (unsigned int) ((arg1)->modifiers);
32236   jresult = result;
32237   return jresult;
32238 }
32239
32240
32241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32242   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32243   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32244
32245   arg1 = (Dali::WheelEvent *)jarg1;
32246   arg2 = (Dali::Vector2 *)jarg2;
32247   if (arg1) (arg1)->point = *arg2;
32248 }
32249
32250
32251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32252   void * jresult ;
32253   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32254   Dali::Vector2 *result = 0 ;
32255
32256   arg1 = (Dali::WheelEvent *)jarg1;
32257   result = (Dali::Vector2 *)& ((arg1)->point);
32258   jresult = (void *)result;
32259   return jresult;
32260 }
32261
32262
32263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32264   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32265   int arg2 ;
32266
32267   arg1 = (Dali::WheelEvent *)jarg1;
32268   arg2 = (int)jarg2;
32269   if (arg1) (arg1)->z = arg2;
32270 }
32271
32272
32273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32274   int jresult ;
32275   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32276   int result;
32277
32278   arg1 = (Dali::WheelEvent *)jarg1;
32279   result = (int) ((arg1)->z);
32280   jresult = result;
32281   return jresult;
32282 }
32283
32284
32285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32286   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32287   unsigned int arg2 ;
32288
32289   arg1 = (Dali::WheelEvent *)jarg1;
32290   arg2 = (unsigned int)jarg2;
32291   if (arg1) (arg1)->timeStamp = arg2;
32292 }
32293
32294
32295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32296   unsigned int jresult ;
32297   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32298   unsigned int result;
32299
32300   arg1 = (Dali::WheelEvent *)jarg1;
32301   result = (unsigned int) ((arg1)->timeStamp);
32302   jresult = result;
32303   return jresult;
32304 }
32305
32306 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32307   char * jresult ;
32308   Dali::KeyEvent *arg1 = 0 ;
32309   std::string result;
32310
32311   arg1 = (Dali::KeyEvent *)jarg1;
32312   if (!arg1) {
32313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32314     return 0;
32315   }
32316   {
32317     try {
32318       result = arg1->GetDeviceName();
32319     } catch (std::out_of_range& e) {
32320       {
32321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32322       };
32323     } catch (std::exception& e) {
32324       {
32325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32326       };
32327     } catch (Dali::DaliException e) {
32328       {
32329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32330       };
32331     } catch (...) {
32332       {
32333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32334       };
32335     }
32336   }
32337
32338   jresult = SWIG_csharp_string_callback((&result)->c_str());
32339   return jresult;
32340 }
32341
32342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32343   int jresult ;
32344   Dali::KeyEvent *arg1 = 0 ;
32345   Dali::Device::Class::Type result;
32346
32347   arg1 = (Dali::KeyEvent *)jarg1;
32348   if (!arg1) {
32349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32350     return 0;
32351   }
32352   {
32353     try {
32354       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32355     } catch (std::out_of_range& e) {
32356       {
32357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32358       };
32359     } catch (std::exception& e) {
32360       {
32361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32362       };
32363     } catch (Dali::DaliException e) {
32364       {
32365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32366       };
32367     } catch (...) {
32368       {
32369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32370       };
32371     }
32372   }
32373
32374   jresult = (int)result;
32375   return jresult;
32376 }
32377
32378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32379   int jresult ;
32380   Dali::KeyEvent *arg1 = 0 ;
32381   Dali::Device::Subclass::Type result;
32382
32383   arg1 = (Dali::KeyEvent *)jarg1;
32384   if (!arg1) {
32385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32386     return 0;
32387   }
32388   {
32389     try {
32390       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32391     } catch (std::out_of_range& e) {
32392       {
32393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32394       };
32395     } catch (std::exception& e) {
32396       {
32397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32398       };
32399     } catch (Dali::DaliException e) {
32400       {
32401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32402       };
32403     } catch (...) {
32404       {
32405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32406       };
32407     }
32408   }
32409
32410   jresult = (int)result;
32411   return jresult;
32412 }
32413
32414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32415   Dali::Actor arg1 ;
32416   Dali::Actor *argp1 ;
32417
32418   argp1 = (Dali::Actor *)jarg1;
32419   if (!argp1) {
32420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32421     return ;
32422   }
32423   arg1 = *argp1;
32424   {
32425     try {
32426       arg1.Raise();
32427     } catch (std::out_of_range& e) {
32428       {
32429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32430       };
32431     } catch (std::exception& e) {
32432       {
32433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32434       };
32435     } catch (Dali::DaliException e) {
32436       {
32437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32438       };
32439     } catch (...) {
32440       {
32441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32442       };
32443     }
32444   }
32445
32446 }
32447
32448
32449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32450   Dali::Actor arg1 ;
32451   Dali::Actor *argp1 ;
32452
32453   argp1 = (Dali::Actor *)jarg1;
32454   if (!argp1) {
32455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32456     return ;
32457   }
32458   arg1 = *argp1;
32459   {
32460     try {
32461       arg1.Lower();
32462     } catch (std::out_of_range& e) {
32463       {
32464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32465       };
32466     } catch (std::exception& e) {
32467       {
32468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32469       };
32470     } catch (Dali::DaliException e) {
32471       {
32472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32473       };
32474     } catch (...) {
32475       {
32476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32477       };
32478     }
32479   }
32480
32481 }
32482
32483
32484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32485   Dali::Actor arg1 ;
32486   Dali::Actor *argp1 ;
32487
32488   argp1 = (Dali::Actor *)jarg1;
32489   if (!argp1) {
32490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32491     return ;
32492   }
32493   arg1 = *argp1;
32494   {
32495     try {
32496       arg1.RaiseToTop();
32497     } catch (std::out_of_range& e) {
32498       {
32499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32500       };
32501     } catch (std::exception& e) {
32502       {
32503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32504       };
32505     } catch (Dali::DaliException e) {
32506       {
32507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32508       };
32509     } catch (...) {
32510       {
32511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32512       };
32513     }
32514   }
32515
32516 }
32517
32518
32519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32520   Dali::Actor arg1 ;
32521   Dali::Actor *argp1 ;
32522
32523   argp1 = (Dali::Actor *)jarg1;
32524   if (!argp1) {
32525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32526     return ;
32527   }
32528   arg1 = *argp1;
32529   {
32530     try {
32531       arg1.LowerToBottom();
32532     } catch (std::out_of_range& e) {
32533       {
32534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32535       };
32536     } catch (std::exception& e) {
32537       {
32538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32539       };
32540     } catch (Dali::DaliException e) {
32541       {
32542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32543       };
32544     } catch (...) {
32545       {
32546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32547       };
32548     }
32549   }
32550
32551 }
32552
32553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32554   Dali::Actor arg1 ;
32555   Dali::Actor arg2 ;
32556   Dali::Actor *argp1 ;
32557   Dali::Actor *argp2 ;
32558
32559   argp1 = (Dali::Actor *)jarg1;
32560   if (!argp1) {
32561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32562     return ;
32563   }
32564   arg1 = *argp1;
32565   argp2 = (Dali::Actor *)jarg2;
32566   if (!argp2) {
32567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32568     return ;
32569   }
32570   arg2 = *argp2;
32571   {
32572     try {
32573       arg1.RaiseAbove(arg2);
32574     } catch (std::out_of_range& e) {
32575       {
32576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32577       };
32578     } catch (std::exception& e) {
32579       {
32580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32581       };
32582     } catch (Dali::DaliException e) {
32583       {
32584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32585       };
32586     } catch (...) {
32587       {
32588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32589       };
32590     }
32591   }
32592
32593 }
32594
32595
32596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32597   Dali::Actor arg1 ;
32598   Dali::Actor arg2 ;
32599   Dali::Actor *argp1 ;
32600   Dali::Actor *argp2 ;
32601
32602   argp1 = (Dali::Actor *)jarg1;
32603   if (!argp1) {
32604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32605     return ;
32606   }
32607   arg1 = *argp1;
32608   argp2 = (Dali::Actor *)jarg2;
32609   if (!argp2) {
32610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32611     return ;
32612   }
32613   arg2 = *argp2;
32614   {
32615     try {
32616       arg1.LowerBelow(arg2);
32617     } catch (std::out_of_range& e) {
32618       {
32619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32620       };
32621     } catch (std::exception& e) {
32622       {
32623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32624       };
32625     } catch (Dali::DaliException e) {
32626       {
32627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32628       };
32629     } catch (...) {
32630       {
32631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32632       };
32633     }
32634   }
32635
32636 }
32637
32638
32639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32640   void * jresult ;
32641   Dali::Actor arg1 ;
32642   Dali::Actor *argp1 ;
32643   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32644
32645   argp1 = (Dali::Actor *)jarg1;
32646   if (!argp1) {
32647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32648     return 0;
32649   }
32650   arg1 = *argp1;
32651   {
32652     try {
32653       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32654     } catch (std::out_of_range& e) {
32655       {
32656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32657       };
32658     } catch (std::exception& e) {
32659       {
32660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32661       };
32662     } catch (Dali::DaliException e) {
32663       {
32664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32665       };
32666     } catch (...) {
32667       {
32668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32669       };
32670     }
32671   }
32672
32673   jresult = (void *)result;
32674   return jresult;
32675 }
32676
32677
32678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32679   void * jresult ;
32680   Dali::Actor *arg1 ;
32681   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32682
32683   arg1 = (Dali::Actor *)jarg1;
32684   {
32685     try {
32686       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32687     } catch (std::out_of_range& e) {
32688       {
32689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32690       };
32691     } catch (std::exception& e) {
32692       {
32693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32694       };
32695     } catch (Dali::DaliException e) {
32696       {
32697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32698       };
32699     } catch (...) {
32700       {
32701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32702       };
32703     }
32704   }
32705
32706   jresult = (void *)result;
32707   return jresult;
32708 }
32709
32710
32711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32712   int jresult ;
32713   int result;
32714
32715   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32716   jresult = (int)result;
32717   return jresult;
32718 }
32719
32720
32721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32722   int jresult ;
32723   int result;
32724
32725   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32726   jresult = (int)result;
32727   return jresult;
32728 }
32729
32730
32731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32732   int jresult ;
32733   int result;
32734
32735   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32736   jresult = (int)result;
32737   return jresult;
32738 }
32739
32740
32741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32742   int jresult ;
32743   int result;
32744
32745   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32746   jresult = (int)result;
32747   return jresult;
32748 }
32749
32750
32751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32752   int jresult ;
32753   int result;
32754
32755   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32756   jresult = (int)result;
32757   return jresult;
32758 }
32759
32760
32761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32762   int jresult ;
32763   int result;
32764
32765   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32766   jresult = (int)result;
32767   return jresult;
32768 }
32769
32770
32771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32772   int jresult ;
32773   int result;
32774
32775   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32776   jresult = (int)result;
32777   return jresult;
32778 }
32779
32780
32781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32782   int jresult ;
32783   int result;
32784
32785   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32786   jresult = (int)result;
32787   return jresult;
32788 }
32789
32790
32791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32792   int jresult ;
32793   int result;
32794
32795   result = (int)Dali::Actor::Property::SIZE;
32796   jresult = (int)result;
32797   return jresult;
32798 }
32799
32800
32801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32802   int jresult ;
32803   int result;
32804
32805   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32806   jresult = (int)result;
32807   return jresult;
32808 }
32809
32810
32811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32812   int jresult ;
32813   int result;
32814
32815   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32816   jresult = (int)result;
32817   return jresult;
32818 }
32819
32820
32821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32822   int jresult ;
32823   int result;
32824
32825   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32826   jresult = (int)result;
32827   return jresult;
32828 }
32829
32830
32831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32832   int jresult ;
32833   int result;
32834
32835   result = (int)Dali::Actor::Property::POSITION;
32836   jresult = (int)result;
32837   return jresult;
32838 }
32839
32840
32841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32842   int jresult ;
32843   int result;
32844
32845   result = (int)Dali::Actor::Property::POSITION_X;
32846   jresult = (int)result;
32847   return jresult;
32848 }
32849
32850
32851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32852   int jresult ;
32853   int result;
32854
32855   result = (int)Dali::Actor::Property::POSITION_Y;
32856   jresult = (int)result;
32857   return jresult;
32858 }
32859
32860
32861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32862   int jresult ;
32863   int result;
32864
32865   result = (int)Dali::Actor::Property::POSITION_Z;
32866   jresult = (int)result;
32867   return jresult;
32868 }
32869
32870
32871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32872   int jresult ;
32873   int result;
32874
32875   result = (int)Dali::Actor::Property::WORLD_POSITION;
32876   jresult = (int)result;
32877   return jresult;
32878 }
32879
32880
32881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32882   int jresult ;
32883   int result;
32884
32885   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32886   jresult = (int)result;
32887   return jresult;
32888 }
32889
32890
32891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32892   int jresult ;
32893   int result;
32894
32895   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32896   jresult = (int)result;
32897   return jresult;
32898 }
32899
32900
32901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32902   int jresult ;
32903   int result;
32904
32905   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32906   jresult = (int)result;
32907   return jresult;
32908 }
32909
32910
32911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32912   int jresult ;
32913   int result;
32914
32915   result = (int)Dali::Actor::Property::ORIENTATION;
32916   jresult = (int)result;
32917   return jresult;
32918 }
32919
32920
32921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32922   int jresult ;
32923   int result;
32924
32925   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32926   jresult = (int)result;
32927   return jresult;
32928 }
32929
32930
32931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32932   int jresult ;
32933   int result;
32934
32935   result = (int)Dali::Actor::Property::SCALE;
32936   jresult = (int)result;
32937   return jresult;
32938 }
32939
32940
32941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
32942   int jresult ;
32943   int result;
32944
32945   result = (int)Dali::Actor::Property::SCALE_X;
32946   jresult = (int)result;
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
32952   int jresult ;
32953   int result;
32954
32955   result = (int)Dali::Actor::Property::SCALE_Y;
32956   jresult = (int)result;
32957   return jresult;
32958 }
32959
32960
32961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
32962   int jresult ;
32963   int result;
32964
32965   result = (int)Dali::Actor::Property::SCALE_Z;
32966   jresult = (int)result;
32967   return jresult;
32968 }
32969
32970
32971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
32972   int jresult ;
32973   int result;
32974
32975   result = (int)Dali::Actor::Property::WORLD_SCALE;
32976   jresult = (int)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
32982   int jresult ;
32983   int result;
32984
32985   result = (int)Dali::Actor::Property::VISIBLE;
32986   jresult = (int)result;
32987   return jresult;
32988 }
32989
32990
32991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
32992   int jresult ;
32993   int result;
32994
32995   result = (int)Dali::Actor::Property::COLOR;
32996   jresult = (int)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::COLOR_RED;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::COLOR_GREEN;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::COLOR_BLUE;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::WORLD_COLOR;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::NAME;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::SENSITIVE;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::COLOR_MODE;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::DRAW_MODE;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33152   int jresult ;
33153   int result;
33154
33155   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33156   jresult = (int)result;
33157   return jresult;
33158 }
33159
33160
33161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33162   int jresult ;
33163   int result;
33164
33165   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33166   jresult = (int)result;
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33172   int jresult ;
33173   int result;
33174
33175   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33176   jresult = (int)result;
33177   return jresult;
33178 }
33179
33180
33181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33182   int jresult ;
33183   int result;
33184
33185   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33186   jresult = (int)result;
33187   return jresult;
33188 }
33189
33190
33191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33192   int jresult ;
33193   int result;
33194
33195   result = (int)Dali::Actor::Property::PADDING;
33196   jresult = (int)result;
33197   return jresult;
33198 }
33199
33200
33201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33202   int jresult ;
33203   int result;
33204
33205   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33206   jresult = (int)result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33212   int jresult ;
33213   int result;
33214
33215   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33216   jresult = (int)result;
33217   return jresult;
33218 }
33219
33220
33221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33222   int jresult ;
33223   int result;
33224
33225   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33226   jresult = (int)result;
33227   return jresult;
33228 }
33229
33230
33231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33232   int jresult ;
33233   int result;
33234
33235   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33236   jresult = (int)result;
33237   return jresult;
33238 }
33239
33240
33241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33242   void * jresult ;
33243   Dali::Actor::Property *result = 0 ;
33244
33245   {
33246     try {
33247       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33248     } catch (std::out_of_range& e) {
33249       {
33250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33251       };
33252     } catch (std::exception& e) {
33253       {
33254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33255       };
33256     } catch (Dali::DaliException e) {
33257       {
33258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33259       };
33260     } catch (...) {
33261       {
33262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33263       };
33264     }
33265   }
33266
33267   jresult = (void *)result;
33268   return jresult;
33269 }
33270
33271
33272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33273   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33274
33275   arg1 = (Dali::Actor::Property *)jarg1;
33276   {
33277     try {
33278       delete arg1;
33279     } catch (std::out_of_range& e) {
33280       {
33281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33282       };
33283     } catch (std::exception& e) {
33284       {
33285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33286       };
33287     } catch (Dali::DaliException e) {
33288       {
33289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33290       };
33291     } catch (...) {
33292       {
33293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33294       };
33295     }
33296   }
33297
33298 }
33299
33300
33301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33302   void * jresult ;
33303   Dali::Actor *result = 0 ;
33304
33305   {
33306     try {
33307       result = (Dali::Actor *)new Dali::Actor();
33308     } catch (std::out_of_range& e) {
33309       {
33310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33311       };
33312     } catch (std::exception& e) {
33313       {
33314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33315       };
33316     } catch (Dali::DaliException e) {
33317       {
33318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33319       };
33320     } catch (...) {
33321       {
33322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33323       };
33324     }
33325   }
33326
33327   jresult = (void *)result;
33328   return jresult;
33329 }
33330
33331
33332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33333   void * jresult ;
33334   Dali::Actor result;
33335
33336   {
33337     try {
33338       result = Dali::Actor::New();
33339     } catch (std::out_of_range& e) {
33340       {
33341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33342       };
33343     } catch (std::exception& e) {
33344       {
33345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33346       };
33347     } catch (Dali::DaliException e) {
33348       {
33349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33350       };
33351     } catch (...) {
33352       {
33353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33354       };
33355     }
33356   }
33357
33358   jresult = new Dali::Actor((const Dali::Actor &)result);
33359   return jresult;
33360 }
33361
33362
33363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33364   void * jresult ;
33365   Dali::BaseHandle arg1 ;
33366   Dali::BaseHandle *argp1 ;
33367   Dali::Actor result;
33368
33369   argp1 = (Dali::BaseHandle *)jarg1;
33370   if (!argp1) {
33371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33372     return 0;
33373   }
33374   arg1 = *argp1;
33375   {
33376     try {
33377       result = Dali::Actor::DownCast(arg1);
33378     } catch (std::out_of_range& e) {
33379       {
33380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33381       };
33382     } catch (std::exception& e) {
33383       {
33384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33385       };
33386     } catch (Dali::DaliException e) {
33387       {
33388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33389       };
33390     } catch (...) {
33391       {
33392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33393       };
33394     }
33395   }
33396
33397   jresult = new Dali::Actor((const Dali::Actor &)result);
33398   return jresult;
33399 }
33400
33401
33402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33403   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33404
33405   arg1 = (Dali::Actor *)jarg1;
33406   {
33407     try {
33408       delete arg1;
33409     } catch (std::out_of_range& e) {
33410       {
33411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33412       };
33413     } catch (std::exception& e) {
33414       {
33415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33416       };
33417     } catch (Dali::DaliException e) {
33418       {
33419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33420       };
33421     } catch (...) {
33422       {
33423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33424       };
33425     }
33426   }
33427
33428 }
33429
33430
33431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33432   void * jresult ;
33433   Dali::Actor *arg1 = 0 ;
33434   Dali::Actor *result = 0 ;
33435
33436   arg1 = (Dali::Actor *)jarg1;
33437   if (!arg1) {
33438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33439     return 0;
33440   }
33441   {
33442     try {
33443       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33444     } catch (std::out_of_range& e) {
33445       {
33446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33447       };
33448     } catch (std::exception& e) {
33449       {
33450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33451       };
33452     } catch (Dali::DaliException e) {
33453       {
33454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33455       };
33456     } catch (...) {
33457       {
33458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33459       };
33460     }
33461   }
33462
33463   jresult = (void *)result;
33464   return jresult;
33465 }
33466
33467
33468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33469   void * jresult ;
33470   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33471   Dali::Actor *arg2 = 0 ;
33472   Dali::Actor *result = 0 ;
33473
33474   arg1 = (Dali::Actor *)jarg1;
33475   arg2 = (Dali::Actor *)jarg2;
33476   if (!arg2) {
33477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33478     return 0;
33479   }
33480   {
33481     try {
33482       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33483     } catch (std::out_of_range& e) {
33484       {
33485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33486       };
33487     } catch (std::exception& e) {
33488       {
33489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33490       };
33491     } catch (Dali::DaliException e) {
33492       {
33493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33494       };
33495     } catch (...) {
33496       {
33497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33498       };
33499     }
33500   }
33501
33502   jresult = (void *)result;
33503   return jresult;
33504 }
33505
33506
33507 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33508   char * jresult ;
33509   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33510   std::string *result = 0 ;
33511
33512   arg1 = (Dali::Actor *)jarg1;
33513   {
33514     try {
33515       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33516       result = (std::string *) &name;
33517     } catch (std::out_of_range& e) {
33518       {
33519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33520       };
33521     } catch (std::exception& e) {
33522       {
33523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33524       };
33525     } catch (Dali::DaliException e) {
33526       {
33527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33528       };
33529     } catch (...) {
33530       {
33531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33532       };
33533     }
33534   }
33535
33536   jresult = SWIG_csharp_string_callback(result->c_str());
33537   return jresult;
33538 }
33539
33540
33541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33542   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33543   std::string *arg2 = 0 ;
33544
33545   arg1 = (Dali::Actor *)jarg1;
33546   if (!jarg2) {
33547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33548     return ;
33549   }
33550   std::string arg2_str(jarg2);
33551   arg2 = &arg2_str;
33552   {
33553     try {
33554       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33555     } catch (std::out_of_range& e) {
33556       {
33557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33558       };
33559     } catch (std::exception& e) {
33560       {
33561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33562       };
33563     } catch (Dali::DaliException e) {
33564       {
33565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33566       };
33567     } catch (...) {
33568       {
33569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33570       };
33571     }
33572   }
33573
33574
33575   //argout typemap for const std::string&
33576
33577 }
33578
33579
33580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33581   unsigned int jresult ;
33582   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33583   unsigned int result;
33584
33585   arg1 = (Dali::Actor *)jarg1;
33586
33587   if(!arg1) {
33588     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33589     return -1;
33590   }
33591
33592   {
33593     try {
33594       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33595     } catch (std::out_of_range& e) {
33596       {
33597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33598       };
33599     } catch (std::exception& e) {
33600       {
33601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33602       };
33603     } catch (Dali::DaliException e) {
33604       {
33605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33606       };
33607     } catch (...) {
33608       {
33609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33610       };
33611     }
33612   }
33613
33614   jresult = result;
33615   return jresult;
33616 }
33617
33618
33619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33620   unsigned int jresult ;
33621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33622   bool result;
33623
33624   arg1 = (Dali::Actor *)jarg1;
33625   {
33626     try {
33627       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33628     } catch (std::out_of_range& e) {
33629       {
33630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33631       };
33632     } catch (std::exception& e) {
33633       {
33634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33635       };
33636     } catch (Dali::DaliException e) {
33637       {
33638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33639       };
33640     } catch (...) {
33641       {
33642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33643       };
33644     }
33645   }
33646
33647   jresult = result;
33648   return jresult;
33649 }
33650
33651
33652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33653   unsigned int jresult ;
33654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33655   bool result;
33656
33657   arg1 = (Dali::Actor *)jarg1;
33658   {
33659     try {
33660       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33661     } catch (std::out_of_range& e) {
33662       {
33663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33664       };
33665     } catch (std::exception& e) {
33666       {
33667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33668       };
33669     } catch (Dali::DaliException e) {
33670       {
33671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33672       };
33673     } catch (...) {
33674       {
33675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33676       };
33677     }
33678   }
33679
33680   jresult = result;
33681   return jresult;
33682 }
33683
33684
33685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33686   unsigned int jresult ;
33687   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33688   bool result;
33689
33690   arg1 = (Dali::Actor *)jarg1;
33691   {
33692     try {
33693       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33694     } catch (std::out_of_range& e) {
33695       {
33696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33697       };
33698     } catch (std::exception& e) {
33699       {
33700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33701       };
33702     } catch (Dali::DaliException e) {
33703       {
33704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33705       };
33706     } catch (...) {
33707       {
33708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33709       };
33710     }
33711   }
33712
33713   jresult = result;
33714   return jresult;
33715 }
33716
33717
33718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33719   void * jresult ;
33720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33721   Dali::Layer result;
33722
33723   arg1 = (Dali::Actor *)jarg1;
33724   {
33725     try {
33726       result = (arg1)->GetLayer();
33727     } catch (std::out_of_range& e) {
33728       {
33729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33730       };
33731     } catch (std::exception& e) {
33732       {
33733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33734       };
33735     } catch (Dali::DaliException e) {
33736       {
33737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33738       };
33739     } catch (...) {
33740       {
33741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33742       };
33743     }
33744   }
33745
33746   jresult = new Dali::Layer((const Dali::Layer &)result);
33747   return jresult;
33748 }
33749
33750
33751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33752   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33753   Dali::Actor arg2 ;
33754   Dali::Actor *argp2 ;
33755
33756   arg1 = (Dali::Actor *)jarg1;
33757   argp2 = (Dali::Actor *)jarg2;
33758   if (!argp2) {
33759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33760     return ;
33761   }
33762   arg2 = *argp2;
33763   {
33764     try {
33765       (arg1)->Add(arg2);
33766     } catch (std::out_of_range& e) {
33767       {
33768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33769       };
33770     } catch (std::exception& e) {
33771       {
33772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33773       };
33774     } catch (Dali::DaliException e) {
33775       {
33776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33777       };
33778     } catch (...) {
33779       {
33780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33781       };
33782     }
33783   }
33784
33785 }
33786
33787
33788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33789   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33790   Dali::Actor arg2 ;
33791   Dali::Actor *argp2 ;
33792
33793   arg1 = (Dali::Actor *)jarg1;
33794   argp2 = (Dali::Actor *)jarg2;
33795   if (!argp2) {
33796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33797     return ;
33798   }
33799   arg2 = *argp2;
33800   {
33801     try {
33802       (arg1)->Remove(arg2);
33803     } catch (std::out_of_range& e) {
33804       {
33805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33806       };
33807     } catch (std::exception& e) {
33808       {
33809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33810       };
33811     } catch (Dali::DaliException e) {
33812       {
33813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33814       };
33815     } catch (...) {
33816       {
33817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33818       };
33819     }
33820   }
33821
33822 }
33823
33824
33825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33826   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33827
33828   arg1 = (Dali::Actor *)jarg1;
33829   {
33830     try {
33831       (arg1)->Unparent();
33832     } catch (std::out_of_range& e) {
33833       {
33834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33835       };
33836     } catch (std::exception& e) {
33837       {
33838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33839       };
33840     } catch (Dali::DaliException e) {
33841       {
33842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33843       };
33844     } catch (...) {
33845       {
33846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33847       };
33848     }
33849   }
33850
33851 }
33852
33853
33854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33855   unsigned int jresult ;
33856   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33857   unsigned int result;
33858
33859   arg1 = (Dali::Actor *)jarg1;
33860   {
33861     try {
33862       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33863     } catch (std::out_of_range& e) {
33864       {
33865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33866       };
33867     } catch (std::exception& e) {
33868       {
33869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33870       };
33871     } catch (Dali::DaliException e) {
33872       {
33873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33874       };
33875     } catch (...) {
33876       {
33877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33878       };
33879     }
33880   }
33881
33882   jresult = result;
33883   return jresult;
33884 }
33885
33886
33887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33888   void * jresult ;
33889   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33890   unsigned int arg2 ;
33891   Dali::Actor result;
33892
33893   arg1 = (Dali::Actor *)jarg1;
33894   arg2 = (unsigned int)jarg2;
33895   {
33896     try {
33897       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33898     } catch (std::out_of_range& e) {
33899       {
33900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33901       };
33902     } catch (std::exception& e) {
33903       {
33904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33905       };
33906     } catch (Dali::DaliException e) {
33907       {
33908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33909       };
33910     } catch (...) {
33911       {
33912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33913       };
33914     }
33915   }
33916
33917   jresult = new Dali::Actor((const Dali::Actor &)result);
33918   return jresult;
33919 }
33920
33921
33922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
33923   void * jresult ;
33924   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33925   std::string *arg2 = 0 ;
33926   Dali::Actor result;
33927
33928   arg1 = (Dali::Actor *)jarg1;
33929   if (!jarg2) {
33930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33931     return 0;
33932   }
33933   std::string arg2_str(jarg2);
33934   arg2 = &arg2_str;
33935   {
33936     try {
33937       result = (arg1)->FindChildByName((std::string const &)*arg2);
33938     } catch (std::out_of_range& e) {
33939       {
33940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33941       };
33942     } catch (std::exception& e) {
33943       {
33944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33945       };
33946     } catch (Dali::DaliException e) {
33947       {
33948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33949       };
33950     } catch (...) {
33951       {
33952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33953       };
33954     }
33955   }
33956
33957   jresult = new Dali::Actor((const Dali::Actor &)result);
33958
33959   //argout typemap for const std::string&
33960
33961   return jresult;
33962 }
33963
33964
33965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
33966   void * jresult ;
33967   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33968   unsigned int arg2 ;
33969   Dali::Actor result;
33970
33971   arg1 = (Dali::Actor *)jarg1;
33972   arg2 = (unsigned int)jarg2;
33973   {
33974     try {
33975       result = (arg1)->FindChildById(arg2);
33976     } catch (std::out_of_range& e) {
33977       {
33978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33979       };
33980     } catch (std::exception& e) {
33981       {
33982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33983       };
33984     } catch (Dali::DaliException e) {
33985       {
33986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33987       };
33988     } catch (...) {
33989       {
33990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33991       };
33992     }
33993   }
33994
33995   jresult = new Dali::Actor((const Dali::Actor &)result);
33996   return jresult;
33997 }
33998
33999
34000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34001   void * jresult ;
34002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34003   Dali::Actor result;
34004
34005   arg1 = (Dali::Actor *)jarg1;
34006   {
34007     try {
34008       result = ((Dali::Actor const *)arg1)->GetParent();
34009     } catch (std::out_of_range& e) {
34010       {
34011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34012       };
34013     } catch (std::exception& e) {
34014       {
34015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34016       };
34017     } catch (Dali::DaliException e) {
34018       {
34019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34020       };
34021     } catch (...) {
34022       {
34023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34024       };
34025     }
34026   }
34027
34028   jresult = new Dali::Actor((const Dali::Actor &)result);
34029   return jresult;
34030 }
34031
34032
34033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34034   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34035   Dali::Vector3 *arg2 = 0 ;
34036
34037   arg1 = (Dali::Actor *)jarg1;
34038   arg2 = (Dali::Vector3 *)jarg2;
34039   if (!arg2) {
34040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34041     return ;
34042   }
34043   {
34044     try {
34045       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34046     } catch (std::out_of_range& e) {
34047       {
34048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34049       };
34050     } catch (std::exception& e) {
34051       {
34052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34053       };
34054     } catch (Dali::DaliException e) {
34055       {
34056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34057       };
34058     } catch (...) {
34059       {
34060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34061       };
34062     }
34063   }
34064
34065 }
34066
34067
34068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34069   void * jresult ;
34070   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34071   Dali::Vector3 result;
34072
34073   arg1 = (Dali::Actor *)jarg1;
34074   {
34075     try {
34076       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34077     } catch (std::out_of_range& e) {
34078       {
34079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34080       };
34081     } catch (std::exception& e) {
34082       {
34083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34084       };
34085     } catch (Dali::DaliException e) {
34086       {
34087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34088       };
34089     } catch (...) {
34090       {
34091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34092       };
34093     }
34094   }
34095
34096   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34097   return jresult;
34098 }
34099
34100
34101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34102   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34103   Dali::Vector3 *arg2 = 0 ;
34104
34105   arg1 = (Dali::Actor *)jarg1;
34106   arg2 = (Dali::Vector3 *)jarg2;
34107   if (!arg2) {
34108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34109     return ;
34110   }
34111   {
34112     try {
34113       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34114     } catch (std::out_of_range& e) {
34115       {
34116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34117       };
34118     } catch (std::exception& e) {
34119       {
34120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34121       };
34122     } catch (Dali::DaliException e) {
34123       {
34124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34125       };
34126     } catch (...) {
34127       {
34128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34129       };
34130     }
34131   }
34132
34133 }
34134
34135
34136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34137   void * jresult ;
34138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34139   Dali::Vector3 result;
34140
34141   arg1 = (Dali::Actor *)jarg1;
34142   {
34143     try {
34144       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34145     } catch (std::out_of_range& e) {
34146       {
34147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34148       };
34149     } catch (std::exception& e) {
34150       {
34151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34152       };
34153     } catch (Dali::DaliException e) {
34154       {
34155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34156       };
34157     } catch (...) {
34158       {
34159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34160       };
34161     }
34162   }
34163
34164   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34165   return jresult;
34166 }
34167
34168
34169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34170   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34171   float arg2 ;
34172   float arg3 ;
34173
34174   arg1 = (Dali::Actor *)jarg1;
34175   arg2 = (float)jarg2;
34176   arg3 = (float)jarg3;
34177   {
34178     try {
34179       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34180     } catch (std::out_of_range& e) {
34181       {
34182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34183       };
34184     } catch (std::exception& e) {
34185       {
34186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34187       };
34188     } catch (Dali::DaliException e) {
34189       {
34190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34191       };
34192     } catch (...) {
34193       {
34194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34195       };
34196     }
34197   }
34198
34199 }
34200
34201
34202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34203   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34204   float arg2 ;
34205   float arg3 ;
34206   float arg4 ;
34207
34208   arg1 = (Dali::Actor *)jarg1;
34209   arg2 = (float)jarg2;
34210   arg3 = (float)jarg3;
34211   arg4 = (float)jarg4;
34212   {
34213     try {
34214       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34215     } catch (std::out_of_range& e) {
34216       {
34217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34218       };
34219     } catch (std::exception& e) {
34220       {
34221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34222       };
34223     } catch (Dali::DaliException e) {
34224       {
34225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34226       };
34227     } catch (...) {
34228       {
34229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34230       };
34231     }
34232   }
34233
34234 }
34235
34236
34237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34238   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34239   Dali::Vector2 *arg2 = 0 ;
34240
34241   arg1 = (Dali::Actor *)jarg1;
34242   arg2 = (Dali::Vector2 *)jarg2;
34243   if (!arg2) {
34244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34245     return ;
34246   }
34247   {
34248     try {
34249       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34250     } catch (std::out_of_range& e) {
34251       {
34252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34253       };
34254     } catch (std::exception& e) {
34255       {
34256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34257       };
34258     } catch (Dali::DaliException e) {
34259       {
34260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34261       };
34262     } catch (...) {
34263       {
34264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34265       };
34266     }
34267   }
34268
34269 }
34270
34271
34272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34273   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34274   Dali::Vector3 *arg2 = 0 ;
34275
34276   arg1 = (Dali::Actor *)jarg1;
34277   arg2 = (Dali::Vector3 *)jarg2;
34278   if (!arg2) {
34279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34280     return ;
34281   }
34282   {
34283     try {
34284       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34285     } catch (std::out_of_range& e) {
34286       {
34287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34288       };
34289     } catch (std::exception& e) {
34290       {
34291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34292       };
34293     } catch (Dali::DaliException e) {
34294       {
34295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34296       };
34297     } catch (...) {
34298       {
34299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34300       };
34301     }
34302   }
34303
34304 }
34305
34306
34307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34308   void * jresult ;
34309   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34310   Dali::Vector3 result;
34311
34312   arg1 = (Dali::Actor *)jarg1;
34313   {
34314     try {
34315       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34316     } catch (std::out_of_range& e) {
34317       {
34318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34319       };
34320     } catch (std::exception& e) {
34321       {
34322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34323       };
34324     } catch (Dali::DaliException e) {
34325       {
34326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34327       };
34328     } catch (...) {
34329       {
34330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34331       };
34332     }
34333   }
34334
34335   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34336   return jresult;
34337 }
34338
34339
34340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34341   void * jresult ;
34342   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34343   Dali::Vector3 result;
34344
34345   arg1 = (Dali::Actor *)jarg1;
34346   {
34347     try {
34348       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34349     } catch (std::out_of_range& e) {
34350       {
34351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34352       };
34353     } catch (std::exception& e) {
34354       {
34355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34356       };
34357     } catch (Dali::DaliException e) {
34358       {
34359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34360       };
34361     } catch (...) {
34362       {
34363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34364       };
34365     }
34366   }
34367
34368   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34369   return jresult;
34370 }
34371
34372
34373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34374   void * jresult ;
34375   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34376   Dali::Vector3 result;
34377
34378   arg1 = (Dali::Actor *)jarg1;
34379   {
34380     try {
34381       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34382     } catch (std::out_of_range& e) {
34383       {
34384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34385       };
34386     } catch (std::exception& e) {
34387       {
34388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34389       };
34390     } catch (Dali::DaliException e) {
34391       {
34392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34393       };
34394     } catch (...) {
34395       {
34396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34397       };
34398     }
34399   }
34400
34401   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34402   return jresult;
34403 }
34404
34405
34406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34407   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34408   float arg2 ;
34409   float arg3 ;
34410
34411   arg1 = (Dali::Actor *)jarg1;
34412   arg2 = (float)jarg2;
34413   arg3 = (float)jarg3;
34414   {
34415     try {
34416       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34417     } catch (std::out_of_range& e) {
34418       {
34419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34420       };
34421     } catch (std::exception& e) {
34422       {
34423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34424       };
34425     } catch (Dali::DaliException e) {
34426       {
34427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34428       };
34429     } catch (...) {
34430       {
34431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34432       };
34433     }
34434   }
34435
34436 }
34437
34438
34439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34440   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34441   float arg2 ;
34442   float arg3 ;
34443   float arg4 ;
34444
34445   arg1 = (Dali::Actor *)jarg1;
34446   arg2 = (float)jarg2;
34447   arg3 = (float)jarg3;
34448   arg4 = (float)jarg4;
34449   {
34450     try {
34451       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34452     } catch (std::out_of_range& e) {
34453       {
34454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34455       };
34456     } catch (std::exception& e) {
34457       {
34458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34459       };
34460     } catch (Dali::DaliException e) {
34461       {
34462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34463       };
34464     } catch (...) {
34465       {
34466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34467       };
34468     }
34469   }
34470
34471 }
34472
34473
34474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34475   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34476   Dali::Vector3 *arg2 = 0 ;
34477
34478   arg1 = (Dali::Actor *)jarg1;
34479   arg2 = (Dali::Vector3 *)jarg2;
34480   if (!arg2) {
34481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34482     return ;
34483   }
34484   {
34485     try {
34486       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34487     } catch (std::out_of_range& e) {
34488       {
34489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34490       };
34491     } catch (std::exception& e) {
34492       {
34493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34494       };
34495     } catch (Dali::DaliException e) {
34496       {
34497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34498       };
34499     } catch (...) {
34500       {
34501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34502       };
34503     }
34504   }
34505
34506 }
34507
34508
34509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34510   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34511   float arg2 ;
34512
34513   arg1 = (Dali::Actor *)jarg1;
34514   arg2 = (float)jarg2;
34515   {
34516     try {
34517       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34518     } catch (std::out_of_range& e) {
34519       {
34520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34521       };
34522     } catch (std::exception& e) {
34523       {
34524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34525       };
34526     } catch (Dali::DaliException e) {
34527       {
34528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34529       };
34530     } catch (...) {
34531       {
34532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34533       };
34534     }
34535   }
34536
34537 }
34538
34539
34540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34541   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34542   float arg2 ;
34543
34544   arg1 = (Dali::Actor *)jarg1;
34545   arg2 = (float)jarg2;
34546   {
34547     try {
34548       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34549     } catch (std::out_of_range& e) {
34550       {
34551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34552       };
34553     } catch (std::exception& e) {
34554       {
34555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34556       };
34557     } catch (Dali::DaliException e) {
34558       {
34559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34560       };
34561     } catch (...) {
34562       {
34563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34564       };
34565     }
34566   }
34567
34568 }
34569
34570
34571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34572   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34573   float arg2 ;
34574
34575   arg1 = (Dali::Actor *)jarg1;
34576   arg2 = (float)jarg2;
34577   {
34578     try {
34579       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34580     } catch (std::out_of_range& e) {
34581       {
34582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34583       };
34584     } catch (std::exception& e) {
34585       {
34586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34587       };
34588     } catch (Dali::DaliException e) {
34589       {
34590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34591       };
34592     } catch (...) {
34593       {
34594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34595       };
34596     }
34597   }
34598
34599 }
34600
34601
34602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34603   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34604   Dali::Vector3 *arg2 = 0 ;
34605
34606   arg1 = (Dali::Actor *)jarg1;
34607   arg2 = (Dali::Vector3 *)jarg2;
34608   if (!arg2) {
34609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34610     return ;
34611   }
34612   {
34613     try {
34614       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34615     } catch (std::out_of_range& e) {
34616       {
34617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34618       };
34619     } catch (std::exception& e) {
34620       {
34621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34622       };
34623     } catch (Dali::DaliException e) {
34624       {
34625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34626       };
34627     } catch (...) {
34628       {
34629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34630       };
34631     }
34632   }
34633
34634 }
34635
34636
34637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34638   void * jresult ;
34639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34640   Dali::Vector3 result;
34641
34642   arg1 = (Dali::Actor *)jarg1;
34643   {
34644     try {
34645       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34646     } catch (std::out_of_range& e) {
34647       {
34648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34649       };
34650     } catch (std::exception& e) {
34651       {
34652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34653       };
34654     } catch (Dali::DaliException e) {
34655       {
34656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34657       };
34658     } catch (...) {
34659       {
34660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34661       };
34662     }
34663   }
34664
34665   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34666   return jresult;
34667 }
34668
34669
34670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34671   void * jresult ;
34672   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34673   Dali::Vector3 result;
34674
34675   arg1 = (Dali::Actor *)jarg1;
34676   {
34677     try {
34678       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34679     } catch (std::out_of_range& e) {
34680       {
34681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34682       };
34683     } catch (std::exception& e) {
34684       {
34685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34686       };
34687     } catch (Dali::DaliException e) {
34688       {
34689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34690       };
34691     } catch (...) {
34692       {
34693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34694       };
34695     }
34696   }
34697
34698   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34699   return jresult;
34700 }
34701
34702
34703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34705   bool arg2 ;
34706
34707   arg1 = (Dali::Actor *)jarg1;
34708   arg2 = jarg2 ? true : false;
34709   {
34710     try {
34711       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34712     } catch (std::out_of_range& e) {
34713       {
34714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34715       };
34716     } catch (std::exception& e) {
34717       {
34718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34719       };
34720     } catch (Dali::DaliException e) {
34721       {
34722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34723       };
34724     } catch (...) {
34725       {
34726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34727       };
34728     }
34729   }
34730
34731 }
34732
34733
34734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34735   unsigned int jresult ;
34736   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34737   bool result;
34738
34739   arg1 = (Dali::Actor *)jarg1;
34740   {
34741     try {
34742       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34743     } catch (std::out_of_range& e) {
34744       {
34745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34746       };
34747     } catch (std::exception& e) {
34748       {
34749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34750       };
34751     } catch (Dali::DaliException e) {
34752       {
34753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34754       };
34755     } catch (...) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34758       };
34759     }
34760   }
34761
34762   jresult = result;
34763   return jresult;
34764 }
34765
34766
34767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34768   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34769   Dali::Degree *arg2 = 0 ;
34770   Dali::Vector3 *arg3 = 0 ;
34771
34772   arg1 = (Dali::Actor *)jarg1;
34773   arg2 = (Dali::Degree *)jarg2;
34774   if (!arg2) {
34775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34776     return ;
34777   }
34778   arg3 = (Dali::Vector3 *)jarg3;
34779   if (!arg3) {
34780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34781     return ;
34782   }
34783   {
34784     try {
34785       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34786     } catch (std::out_of_range& e) {
34787       {
34788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34789       };
34790     } catch (std::exception& e) {
34791       {
34792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34793       };
34794     } catch (Dali::DaliException e) {
34795       {
34796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34797       };
34798     } catch (...) {
34799       {
34800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34801       };
34802     }
34803   }
34804
34805 }
34806
34807
34808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34809   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34810   Dali::Radian *arg2 = 0 ;
34811   Dali::Vector3 *arg3 = 0 ;
34812
34813   arg1 = (Dali::Actor *)jarg1;
34814   arg2 = (Dali::Radian *)jarg2;
34815   if (!arg2) {
34816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34817     return ;
34818   }
34819   arg3 = (Dali::Vector3 *)jarg3;
34820   if (!arg3) {
34821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34822     return ;
34823   }
34824   {
34825     try {
34826       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34827     } catch (std::out_of_range& e) {
34828       {
34829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34830       };
34831     } catch (std::exception& e) {
34832       {
34833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34834       };
34835     } catch (Dali::DaliException e) {
34836       {
34837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34838       };
34839     } catch (...) {
34840       {
34841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34842       };
34843     }
34844   }
34845
34846 }
34847
34848
34849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34850   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34851   Dali::Quaternion *arg2 = 0 ;
34852
34853   arg1 = (Dali::Actor *)jarg1;
34854   arg2 = (Dali::Quaternion *)jarg2;
34855   if (!arg2) {
34856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34857     return ;
34858   }
34859   {
34860     try {
34861       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34862     } catch (std::out_of_range& e) {
34863       {
34864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34865       };
34866     } catch (std::exception& e) {
34867       {
34868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34869       };
34870     } catch (Dali::DaliException e) {
34871       {
34872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34873       };
34874     } catch (...) {
34875       {
34876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34877       };
34878     }
34879   }
34880
34881 }
34882
34883
34884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34886   Dali::Degree *arg2 = 0 ;
34887   Dali::Vector3 *arg3 = 0 ;
34888
34889   arg1 = (Dali::Actor *)jarg1;
34890   arg2 = (Dali::Degree *)jarg2;
34891   if (!arg2) {
34892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34893     return ;
34894   }
34895   arg3 = (Dali::Vector3 *)jarg3;
34896   if (!arg3) {
34897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34898     return ;
34899   }
34900   {
34901     try {
34902       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34903     } catch (std::out_of_range& e) {
34904       {
34905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34906       };
34907     } catch (std::exception& e) {
34908       {
34909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34910       };
34911     } catch (Dali::DaliException e) {
34912       {
34913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34914       };
34915     } catch (...) {
34916       {
34917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34918       };
34919     }
34920   }
34921
34922 }
34923
34924
34925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34926   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34927   Dali::Radian *arg2 = 0 ;
34928   Dali::Vector3 *arg3 = 0 ;
34929
34930   arg1 = (Dali::Actor *)jarg1;
34931   arg2 = (Dali::Radian *)jarg2;
34932   if (!arg2) {
34933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34934     return ;
34935   }
34936   arg3 = (Dali::Vector3 *)jarg3;
34937   if (!arg3) {
34938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34939     return ;
34940   }
34941   {
34942     try {
34943       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34944     } catch (std::out_of_range& e) {
34945       {
34946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34947       };
34948     } catch (std::exception& e) {
34949       {
34950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34951       };
34952     } catch (Dali::DaliException e) {
34953       {
34954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34955       };
34956     } catch (...) {
34957       {
34958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34959       };
34960     }
34961   }
34962
34963 }
34964
34965
34966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
34967   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34968   Dali::Quaternion *arg2 = 0 ;
34969
34970   arg1 = (Dali::Actor *)jarg1;
34971   arg2 = (Dali::Quaternion *)jarg2;
34972   if (!arg2) {
34973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34974     return ;
34975   }
34976   {
34977     try {
34978       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
34979     } catch (std::out_of_range& e) {
34980       {
34981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34982       };
34983     } catch (std::exception& e) {
34984       {
34985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34986       };
34987     } catch (Dali::DaliException e) {
34988       {
34989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34990       };
34991     } catch (...) {
34992       {
34993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34994       };
34995     }
34996   }
34997
34998 }
34999
35000
35001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35002   void * jresult ;
35003   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35004   Dali::Quaternion result;
35005
35006   arg1 = (Dali::Actor *)jarg1;
35007   {
35008     try {
35009       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35010     } catch (std::out_of_range& e) {
35011       {
35012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35013       };
35014     } catch (std::exception& e) {
35015       {
35016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35017       };
35018     } catch (Dali::DaliException e) {
35019       {
35020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35021       };
35022     } catch (...) {
35023       {
35024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35025       };
35026     }
35027   }
35028
35029   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35030   return jresult;
35031 }
35032
35033
35034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35036   bool arg2 ;
35037
35038   arg1 = (Dali::Actor *)jarg1;
35039   arg2 = jarg2 ? true : false;
35040   {
35041     try {
35042       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35043     } catch (std::out_of_range& e) {
35044       {
35045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35046       };
35047     } catch (std::exception& e) {
35048       {
35049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35050       };
35051     } catch (Dali::DaliException e) {
35052       {
35053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35054       };
35055     } catch (...) {
35056       {
35057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35058       };
35059     }
35060   }
35061
35062 }
35063
35064
35065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35066   unsigned int jresult ;
35067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35068   bool result;
35069
35070   arg1 = (Dali::Actor *)jarg1;
35071   {
35072     try {
35073       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35074     } catch (std::out_of_range& e) {
35075       {
35076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35077       };
35078     } catch (std::exception& e) {
35079       {
35080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35081       };
35082     } catch (Dali::DaliException e) {
35083       {
35084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35085       };
35086     } catch (...) {
35087       {
35088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35089       };
35090     }
35091   }
35092
35093   jresult = result;
35094   return jresult;
35095 }
35096
35097
35098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35099   void * jresult ;
35100   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35101   Dali::Quaternion result;
35102
35103   arg1 = (Dali::Actor *)jarg1;
35104   {
35105     try {
35106       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35107     } catch (std::out_of_range& e) {
35108       {
35109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35110       };
35111     } catch (std::exception& e) {
35112       {
35113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35114       };
35115     } catch (Dali::DaliException e) {
35116       {
35117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35118       };
35119     } catch (...) {
35120       {
35121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35122       };
35123     }
35124   }
35125
35126   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35127   return jresult;
35128 }
35129
35130
35131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35132   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35133   float arg2 ;
35134
35135   arg1 = (Dali::Actor *)jarg1;
35136   arg2 = (float)jarg2;
35137   {
35138     try {
35139       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35140     } catch (std::out_of_range& e) {
35141       {
35142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35143       };
35144     } catch (std::exception& e) {
35145       {
35146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35147       };
35148     } catch (Dali::DaliException e) {
35149       {
35150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35151       };
35152     } catch (...) {
35153       {
35154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35155       };
35156     }
35157   }
35158
35159 }
35160
35161
35162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35163   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35164   float arg2 ;
35165   float arg3 ;
35166   float arg4 ;
35167
35168   arg1 = (Dali::Actor *)jarg1;
35169   arg2 = (float)jarg2;
35170   arg3 = (float)jarg3;
35171   arg4 = (float)jarg4;
35172   {
35173     try {
35174       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35175     } catch (std::out_of_range& e) {
35176       {
35177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35178       };
35179     } catch (std::exception& e) {
35180       {
35181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35182       };
35183     } catch (Dali::DaliException e) {
35184       {
35185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35186       };
35187     } catch (...) {
35188       {
35189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35190       };
35191     }
35192   }
35193
35194 }
35195
35196
35197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35198   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35199   Dali::Vector3 *arg2 = 0 ;
35200
35201   arg1 = (Dali::Actor *)jarg1;
35202   arg2 = (Dali::Vector3 *)jarg2;
35203   if (!arg2) {
35204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35205     return ;
35206   }
35207   {
35208     try {
35209       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35210     } catch (std::out_of_range& e) {
35211       {
35212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35213       };
35214     } catch (std::exception& e) {
35215       {
35216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35217       };
35218     } catch (Dali::DaliException e) {
35219       {
35220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35221       };
35222     } catch (...) {
35223       {
35224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35225       };
35226     }
35227   }
35228
35229 }
35230
35231
35232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35233   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35234   Dali::Vector3 *arg2 = 0 ;
35235
35236   arg1 = (Dali::Actor *)jarg1;
35237   arg2 = (Dali::Vector3 *)jarg2;
35238   if (!arg2) {
35239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35240     return ;
35241   }
35242   {
35243     try {
35244       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35245     } catch (std::out_of_range& e) {
35246       {
35247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35248       };
35249     } catch (std::exception& e) {
35250       {
35251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35252       };
35253     } catch (Dali::DaliException e) {
35254       {
35255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35256       };
35257     } catch (...) {
35258       {
35259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35260       };
35261     }
35262   }
35263
35264 }
35265
35266
35267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35268   void * jresult ;
35269   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35270   Dali::Vector3 result;
35271
35272   arg1 = (Dali::Actor *)jarg1;
35273   {
35274     try {
35275       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35276     } catch (std::out_of_range& e) {
35277       {
35278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35279       };
35280     } catch (std::exception& e) {
35281       {
35282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35283       };
35284     } catch (Dali::DaliException e) {
35285       {
35286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35287       };
35288     } catch (...) {
35289       {
35290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35291       };
35292     }
35293   }
35294
35295   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35296   return jresult;
35297 }
35298
35299
35300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35301   void * jresult ;
35302   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35303   Dali::Vector3 result;
35304
35305   arg1 = (Dali::Actor *)jarg1;
35306   {
35307     try {
35308       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35309     } catch (std::out_of_range& e) {
35310       {
35311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35312       };
35313     } catch (std::exception& e) {
35314       {
35315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35316       };
35317     } catch (Dali::DaliException e) {
35318       {
35319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35320       };
35321     } catch (...) {
35322       {
35323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35324       };
35325     }
35326   }
35327
35328   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35329   return jresult;
35330 }
35331
35332
35333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35334   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35335   bool arg2 ;
35336
35337   arg1 = (Dali::Actor *)jarg1;
35338   arg2 = jarg2 ? true : false;
35339   {
35340     try {
35341       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35342     } catch (std::out_of_range& e) {
35343       {
35344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35345       };
35346     } catch (std::exception& e) {
35347       {
35348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35349       };
35350     } catch (Dali::DaliException e) {
35351       {
35352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35353       };
35354     } catch (...) {
35355       {
35356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35357       };
35358     }
35359   }
35360
35361 }
35362
35363
35364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35365   unsigned int jresult ;
35366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35367   bool result;
35368
35369   arg1 = (Dali::Actor *)jarg1;
35370   {
35371     try {
35372       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35373     } catch (std::out_of_range& e) {
35374       {
35375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35376       };
35377     } catch (std::exception& e) {
35378       {
35379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35380       };
35381     } catch (Dali::DaliException e) {
35382       {
35383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35384       };
35385     } catch (...) {
35386       {
35387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35388       };
35389     }
35390   }
35391
35392   jresult = result;
35393   return jresult;
35394 }
35395
35396
35397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35398   void * jresult ;
35399   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35400   Dali::Matrix result;
35401
35402   arg1 = (Dali::Actor *)jarg1;
35403   {
35404     try {
35405       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35406     } catch (std::out_of_range& e) {
35407       {
35408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35409       };
35410     } catch (std::exception& e) {
35411       {
35412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35413       };
35414     } catch (Dali::DaliException e) {
35415       {
35416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35417       };
35418     } catch (...) {
35419       {
35420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35421       };
35422     }
35423   }
35424
35425   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35426   return jresult;
35427 }
35428
35429
35430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35431   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35432   bool arg2 ;
35433
35434   arg1 = (Dali::Actor *)jarg1;
35435   arg2 = jarg2 ? true : false;
35436   {
35437     try {
35438       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35439     } catch (std::out_of_range& e) {
35440       {
35441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35442       };
35443     } catch (std::exception& e) {
35444       {
35445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35446       };
35447     } catch (Dali::DaliException e) {
35448       {
35449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35450       };
35451     } catch (...) {
35452       {
35453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35454       };
35455     }
35456   }
35457
35458 }
35459
35460
35461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35462   unsigned int jresult ;
35463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35464   bool result;
35465
35466   arg1 = (Dali::Actor *)jarg1;
35467   {
35468     try {
35469       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35470     } catch (std::out_of_range& e) {
35471       {
35472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35473       };
35474     } catch (std::exception& e) {
35475       {
35476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35477       };
35478     } catch (Dali::DaliException e) {
35479       {
35480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35481       };
35482     } catch (...) {
35483       {
35484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35485       };
35486     }
35487   }
35488
35489   jresult = result;
35490   return jresult;
35491 }
35492
35493
35494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35496   float arg2 ;
35497
35498   arg1 = (Dali::Actor *)jarg1;
35499   arg2 = (float)jarg2;
35500   {
35501     try {
35502       (arg1)->SetProperty( DevelActor::Property::OPACITY,arg2);
35503     } catch (std::out_of_range& e) {
35504       {
35505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35506       };
35507     } catch (std::exception& e) {
35508       {
35509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35510       };
35511     } catch (Dali::DaliException e) {
35512       {
35513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35514       };
35515     } catch (...) {
35516       {
35517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35518       };
35519     }
35520   }
35521
35522 }
35523
35524
35525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35526   float jresult ;
35527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35528   float result;
35529
35530   arg1 = (Dali::Actor *)jarg1;
35531   {
35532     try {
35533       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( DevelActor::Property::OPACITY );
35534     } catch (std::out_of_range& e) {
35535       {
35536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35537       };
35538     } catch (std::exception& e) {
35539       {
35540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35541       };
35542     } catch (Dali::DaliException e) {
35543       {
35544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35545       };
35546     } catch (...) {
35547       {
35548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35549       };
35550     }
35551   }
35552
35553   jresult = result;
35554   return jresult;
35555 }
35556
35557
35558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35560   Dali::Vector4 *arg2 = 0 ;
35561
35562   arg1 = (Dali::Actor *)jarg1;
35563   arg2 = (Dali::Vector4 *)jarg2;
35564   if (!arg2) {
35565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35566     return ;
35567   }
35568   {
35569     try {
35570       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35571     } catch (std::out_of_range& e) {
35572       {
35573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35574       };
35575     } catch (std::exception& e) {
35576       {
35577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35578       };
35579     } catch (Dali::DaliException e) {
35580       {
35581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35582       };
35583     } catch (...) {
35584       {
35585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35586       };
35587     }
35588   }
35589
35590 }
35591
35592
35593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35594   void * jresult ;
35595   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35596   Dali::Vector4 result;
35597
35598   arg1 = (Dali::Actor *)jarg1;
35599   {
35600     try {
35601       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35602     } catch (std::out_of_range& e) {
35603       {
35604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35605       };
35606     } catch (std::exception& e) {
35607       {
35608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35609       };
35610     } catch (Dali::DaliException e) {
35611       {
35612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35613       };
35614     } catch (...) {
35615       {
35616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35617       };
35618     }
35619   }
35620
35621   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35622   return jresult;
35623 }
35624
35625
35626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35627   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35628   Dali::ColorMode arg2 ;
35629
35630   arg1 = (Dali::Actor *)jarg1;
35631   arg2 = (Dali::ColorMode)jarg2;
35632   {
35633     try {
35634       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35635     } catch (std::out_of_range& e) {
35636       {
35637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35638       };
35639     } catch (std::exception& e) {
35640       {
35641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35642       };
35643     } catch (Dali::DaliException e) {
35644       {
35645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35646       };
35647     } catch (...) {
35648       {
35649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35650       };
35651     }
35652   }
35653
35654 }
35655
35656
35657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35658   int jresult ;
35659   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35660   Dali::ColorMode result;
35661
35662   arg1 = (Dali::Actor *)jarg1;
35663   {
35664     try {
35665       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35666     } catch (std::out_of_range& e) {
35667       {
35668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35669       };
35670     } catch (std::exception& e) {
35671       {
35672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35673       };
35674     } catch (Dali::DaliException e) {
35675       {
35676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35677       };
35678     } catch (...) {
35679       {
35680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35681       };
35682     }
35683   }
35684
35685   jresult = (int)result;
35686   return jresult;
35687 }
35688
35689
35690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35691   void * jresult ;
35692   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35693   Dali::Vector4 result;
35694
35695   arg1 = (Dali::Actor *)jarg1;
35696   {
35697     try {
35698       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35699     } catch (std::out_of_range& e) {
35700       {
35701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35702       };
35703     } catch (std::exception& e) {
35704       {
35705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35706       };
35707     } catch (Dali::DaliException e) {
35708       {
35709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35710       };
35711     } catch (...) {
35712       {
35713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35714       };
35715     }
35716   }
35717
35718   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35719   return jresult;
35720 }
35721
35722
35723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35724   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35725   Dali::DrawMode::Type arg2 ;
35726
35727   arg1 = (Dali::Actor *)jarg1;
35728   arg2 = (Dali::DrawMode::Type)jarg2;
35729   {
35730     try {
35731       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35732     } catch (std::out_of_range& e) {
35733       {
35734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35735       };
35736     } catch (std::exception& e) {
35737       {
35738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35739       };
35740     } catch (Dali::DaliException e) {
35741       {
35742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35743       };
35744     } catch (...) {
35745       {
35746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35747       };
35748     }
35749   }
35750
35751 }
35752
35753
35754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35755   int jresult ;
35756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35757   Dali::DrawMode::Type result;
35758
35759   arg1 = (Dali::Actor *)jarg1;
35760   {
35761     try {
35762       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35763     } catch (std::out_of_range& e) {
35764       {
35765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35766       };
35767     } catch (std::exception& e) {
35768       {
35769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35770       };
35771     } catch (Dali::DaliException e) {
35772       {
35773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35774       };
35775     } catch (...) {
35776       {
35777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35778       };
35779     }
35780   }
35781
35782   jresult = (int)result;
35783   return jresult;
35784 }
35785
35786
35787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35789   bool arg2 ;
35790
35791   arg1 = (Dali::Actor *)jarg1;
35792   arg2 = jarg2 ? true : false;
35793   {
35794     try {
35795       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35796     } catch (std::out_of_range& e) {
35797       {
35798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35799       };
35800     } catch (std::exception& e) {
35801       {
35802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35803       };
35804     } catch (Dali::DaliException e) {
35805       {
35806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35807       };
35808     } catch (...) {
35809       {
35810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35811       };
35812     }
35813   }
35814
35815 }
35816
35817
35818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35819   unsigned int jresult ;
35820   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35821   bool result;
35822
35823   arg1 = (Dali::Actor *)jarg1;
35824   {
35825     try {
35826       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35827     } catch (std::out_of_range& e) {
35828       {
35829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35830       };
35831     } catch (std::exception& e) {
35832       {
35833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35834       };
35835     } catch (Dali::DaliException e) {
35836       {
35837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35838       };
35839     } catch (...) {
35840       {
35841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35842       };
35843     }
35844   }
35845
35846   jresult = result;
35847   return jresult;
35848 }
35849
35850
35851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35852   unsigned int jresult ;
35853   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35854   float *arg2 = 0 ;
35855   float *arg3 = 0 ;
35856   float arg4 ;
35857   float arg5 ;
35858   bool result;
35859
35860   arg1 = (Dali::Actor *)jarg1;
35861   arg2 = (float *)jarg2;
35862   arg3 = (float *)jarg3;
35863   arg4 = (float)jarg4;
35864   arg5 = (float)jarg5;
35865   {
35866     try {
35867       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35868     } catch (std::out_of_range& e) {
35869       {
35870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35871       };
35872     } catch (std::exception& e) {
35873       {
35874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35875       };
35876     } catch (Dali::DaliException e) {
35877       {
35878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35879       };
35880     } catch (...) {
35881       {
35882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35883       };
35884     }
35885   }
35886
35887   jresult = result;
35888   return jresult;
35889 }
35890
35891
35892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35893   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35894   bool arg2 ;
35895
35896   arg1 = (Dali::Actor *)jarg1;
35897   arg2 = jarg2 ? true : false;
35898   {
35899     try {
35900       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
35901     } catch (std::out_of_range& e) {
35902       {
35903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35904       };
35905     } catch (std::exception& e) {
35906       {
35907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35908       };
35909     } catch (Dali::DaliException e) {
35910       {
35911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35912       };
35913     } catch (...) {
35914       {
35915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35916       };
35917     }
35918   }
35919
35920 }
35921
35922
35923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
35924   unsigned int jresult ;
35925   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35926   bool result;
35927
35928   arg1 = (Dali::Actor *)jarg1;
35929   {
35930     try {
35931       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
35932     } catch (std::out_of_range& e) {
35933       {
35934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35935       };
35936     } catch (std::exception& e) {
35937       {
35938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35939       };
35940     } catch (Dali::DaliException e) {
35941       {
35942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35943       };
35944     } catch (...) {
35945       {
35946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35947       };
35948     }
35949   }
35950
35951   jresult = result;
35952   return jresult;
35953 }
35954
35955
35956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
35957   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35958   bool arg2 ;
35959
35960   arg1 = (Dali::Actor *)jarg1;
35961   arg2 = jarg2 ? true : false;
35962   {
35963     try {
35964       (arg1)->SetKeyboardFocusable(arg2);
35965     } catch (std::out_of_range& e) {
35966       {
35967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35968       };
35969     } catch (std::exception& e) {
35970       {
35971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35972       };
35973     } catch (Dali::DaliException e) {
35974       {
35975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35976       };
35977     } catch (...) {
35978       {
35979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35980       };
35981     }
35982   }
35983
35984 }
35985
35986
35987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
35988   unsigned int jresult ;
35989   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35990   bool result;
35991
35992   arg1 = (Dali::Actor *)jarg1;
35993   {
35994     try {
35995       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
35996     } catch (std::out_of_range& e) {
35997       {
35998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35999       };
36000     } catch (std::exception& e) {
36001       {
36002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36003       };
36004     } catch (Dali::DaliException e) {
36005       {
36006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36007       };
36008     } catch (...) {
36009       {
36010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36011       };
36012     }
36013   }
36014
36015   jresult = result;
36016   return jresult;
36017 }
36018
36019
36020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36021   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36022   Dali::ResizePolicy::Type arg2 ;
36023   Dali::Dimension::Type arg3 ;
36024
36025   arg1 = (Dali::Actor *)jarg1;
36026   arg2 = (Dali::ResizePolicy::Type)jarg2;
36027   arg3 = (Dali::Dimension::Type)jarg3;
36028   {
36029     try {
36030       (arg1)->SetResizePolicy(arg2,arg3);
36031     } catch (std::out_of_range& e) {
36032       {
36033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36034       };
36035     } catch (std::exception& e) {
36036       {
36037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36038       };
36039     } catch (Dali::DaliException e) {
36040       {
36041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36042       };
36043     } catch (...) {
36044       {
36045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36046       };
36047     }
36048   }
36049
36050 }
36051
36052
36053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36054   int jresult ;
36055   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36056   Dali::Dimension::Type arg2 ;
36057   Dali::ResizePolicy::Type result;
36058
36059   arg1 = (Dali::Actor *)jarg1;
36060   arg2 = (Dali::Dimension::Type)jarg2;
36061   {
36062     try {
36063       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36064     } catch (std::out_of_range& e) {
36065       {
36066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36067       };
36068     } catch (std::exception& e) {
36069       {
36070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36071       };
36072     } catch (Dali::DaliException e) {
36073       {
36074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36075       };
36076     } catch (...) {
36077       {
36078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36079       };
36080     }
36081   }
36082
36083   jresult = (int)result;
36084   return jresult;
36085 }
36086
36087
36088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36090   Dali::SizeScalePolicy::Type arg2 ;
36091
36092   arg1 = (Dali::Actor *)jarg1;
36093   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36094   {
36095     try {
36096       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36097     } catch (std::out_of_range& e) {
36098       {
36099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36100       };
36101     } catch (std::exception& e) {
36102       {
36103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36104       };
36105     } catch (Dali::DaliException e) {
36106       {
36107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36108       };
36109     } catch (...) {
36110       {
36111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36112       };
36113     }
36114   }
36115
36116 }
36117
36118
36119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36120   int jresult ;
36121   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36122   Dali::SizeScalePolicy::Type result;
36123
36124   arg1 = (Dali::Actor *)jarg1;
36125   {
36126     try {
36127       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36128     } catch (std::out_of_range& e) {
36129       {
36130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36131       };
36132     } catch (std::exception& e) {
36133       {
36134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36135       };
36136     } catch (Dali::DaliException e) {
36137       {
36138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36139       };
36140     } catch (...) {
36141       {
36142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36143       };
36144     }
36145   }
36146
36147   jresult = (int)result;
36148   return jresult;
36149 }
36150
36151
36152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36153   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36154   Dali::Vector3 *arg2 = 0 ;
36155
36156   arg1 = (Dali::Actor *)jarg1;
36157   arg2 = (Dali::Vector3 *)jarg2;
36158   if (!arg2) {
36159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36160     return ;
36161   }
36162   {
36163     try {
36164       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36165     } catch (std::out_of_range& e) {
36166       {
36167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36168       };
36169     } catch (std::exception& e) {
36170       {
36171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36172       };
36173     } catch (Dali::DaliException e) {
36174       {
36175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36176       };
36177     } catch (...) {
36178       {
36179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36180       };
36181     }
36182   }
36183
36184 }
36185
36186
36187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36188   void * jresult ;
36189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36190   Dali::Vector3 result;
36191
36192   arg1 = (Dali::Actor *)jarg1;
36193   {
36194     try {
36195       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36196     } catch (std::out_of_range& e) {
36197       {
36198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36199       };
36200     } catch (std::exception& e) {
36201       {
36202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36203       };
36204     } catch (Dali::DaliException e) {
36205       {
36206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36207       };
36208     } catch (...) {
36209       {
36210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36211       };
36212     }
36213   }
36214
36215   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36216   return jresult;
36217 }
36218
36219
36220 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36221   float jresult ;
36222   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36223   float arg2 ;
36224   float result;
36225
36226   arg1 = (Dali::Actor *)jarg1;
36227   arg2 = (float)jarg2;
36228   {
36229     try {
36230       result = (float)(arg1)->GetHeightForWidth(arg2);
36231     } catch (std::out_of_range& e) {
36232       {
36233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36234       };
36235     } catch (std::exception& e) {
36236       {
36237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36238       };
36239     } catch (Dali::DaliException e) {
36240       {
36241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36242       };
36243     } catch (...) {
36244       {
36245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36246       };
36247     }
36248   }
36249
36250   jresult = result;
36251   return jresult;
36252 }
36253
36254
36255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36256   float jresult ;
36257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36258   float arg2 ;
36259   float result;
36260
36261   arg1 = (Dali::Actor *)jarg1;
36262   arg2 = (float)jarg2;
36263   {
36264     try {
36265       result = (float)(arg1)->GetWidthForHeight(arg2);
36266     } catch (std::out_of_range& e) {
36267       {
36268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36269       };
36270     } catch (std::exception& e) {
36271       {
36272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36273       };
36274     } catch (Dali::DaliException e) {
36275       {
36276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36277       };
36278     } catch (...) {
36279       {
36280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36281       };
36282     }
36283   }
36284
36285   jresult = result;
36286   return jresult;
36287 }
36288
36289
36290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36291   float jresult ;
36292   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36293   Dali::Dimension::Type arg2 ;
36294   float result;
36295
36296   arg1 = (Dali::Actor *)jarg1;
36297   arg2 = (Dali::Dimension::Type)jarg2;
36298   {
36299     try {
36300       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36301     } catch (std::out_of_range& e) {
36302       {
36303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36304       };
36305     } catch (std::exception& e) {
36306       {
36307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36308       };
36309     } catch (Dali::DaliException e) {
36310       {
36311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36312       };
36313     } catch (...) {
36314       {
36315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36316       };
36317     }
36318   }
36319
36320   jresult = result;
36321   return jresult;
36322 }
36323
36324
36325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36327   Dali::Padding *arg2 = 0 ;
36328
36329   arg1 = (Dali::Actor *)jarg1;
36330   arg2 = (Dali::Padding *)jarg2;
36331   if (!arg2) {
36332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36333     return ;
36334   }
36335   {
36336     try {
36337       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36338     } catch (std::out_of_range& e) {
36339       {
36340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36341       };
36342     } catch (std::exception& e) {
36343       {
36344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36345       };
36346     } catch (Dali::DaliException e) {
36347       {
36348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36349       };
36350     } catch (...) {
36351       {
36352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36353       };
36354     }
36355   }
36356
36357 }
36358
36359
36360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36362   Dali::Padding *arg2 = 0 ;
36363
36364   arg1 = (Dali::Actor *)jarg1;
36365   arg2 = (Dali::Padding *)jarg2;
36366   if (!arg2) {
36367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36368     return ;
36369   }
36370   {
36371     try {
36372       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36373     } catch (std::out_of_range& e) {
36374       {
36375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36376       };
36377     } catch (std::exception& e) {
36378       {
36379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36380       };
36381     } catch (Dali::DaliException e) {
36382       {
36383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36384       };
36385     } catch (...) {
36386       {
36387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36388       };
36389     }
36390   }
36391
36392 }
36393
36394
36395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36396   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36397   Dali::Vector2 *arg2 = 0 ;
36398
36399   arg1 = (Dali::Actor *)jarg1;
36400   arg2 = (Dali::Vector2 *)jarg2;
36401   if (!arg2) {
36402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36403     return ;
36404   }
36405   {
36406     try {
36407       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36408     } catch (std::out_of_range& e) {
36409       {
36410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36411       };
36412     } catch (std::exception& e) {
36413       {
36414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36415       };
36416     } catch (Dali::DaliException e) {
36417       {
36418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36419       };
36420     } catch (...) {
36421       {
36422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36423       };
36424     }
36425   }
36426
36427 }
36428
36429
36430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36431   void * jresult ;
36432   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36433   Dali::Vector2 result;
36434
36435   arg1 = (Dali::Actor *)jarg1;
36436   {
36437     try {
36438       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36439     } catch (std::out_of_range& e) {
36440       {
36441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36442       };
36443     } catch (std::exception& e) {
36444       {
36445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36446       };
36447     } catch (Dali::DaliException e) {
36448       {
36449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36450       };
36451     } catch (...) {
36452       {
36453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36454       };
36455     }
36456   }
36457
36458   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36459   return jresult;
36460 }
36461
36462
36463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36464   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36465   Dali::Vector2 *arg2 = 0 ;
36466
36467   arg1 = (Dali::Actor *)jarg1;
36468   arg2 = (Dali::Vector2 *)jarg2;
36469   if (!arg2) {
36470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36471     return ;
36472   }
36473   {
36474     try {
36475       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36476     } catch (std::out_of_range& e) {
36477       {
36478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36479       };
36480     } catch (std::exception& e) {
36481       {
36482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36483       };
36484     } catch (Dali::DaliException e) {
36485       {
36486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36487       };
36488     } catch (...) {
36489       {
36490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36491       };
36492     }
36493   }
36494
36495 }
36496
36497
36498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36499   void * jresult ;
36500   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36501   Dali::Vector2 result;
36502
36503   arg1 = (Dali::Actor *)jarg1;
36504   {
36505     try {
36506       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36507     } catch (std::out_of_range& e) {
36508       {
36509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36510       };
36511     } catch (std::exception& e) {
36512       {
36513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36514       };
36515     } catch (Dali::DaliException e) {
36516       {
36517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36518       };
36519     } catch (...) {
36520       {
36521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36522       };
36523     }
36524   }
36525
36526   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36527   return jresult;
36528 }
36529
36530
36531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36532   int jresult ;
36533   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36534   int result;
36535
36536   arg1 = (Dali::Actor *)jarg1;
36537   {
36538     try {
36539       result = (int)(arg1)->GetHierarchyDepth();
36540       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36541     } catch (std::out_of_range& e) {
36542       {
36543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36544       };
36545     } catch (std::exception& e) {
36546       {
36547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36548       };
36549     } catch (Dali::DaliException e) {
36550       {
36551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36552       };
36553     } catch (...) {
36554       {
36555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36556       };
36557     }
36558   }
36559
36560   jresult = result;
36561   return jresult;
36562 }
36563
36564
36565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36566   unsigned int jresult ;
36567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36568   Dali::Renderer *arg2 = 0 ;
36569   unsigned int result;
36570
36571   arg1 = (Dali::Actor *)jarg1;
36572   arg2 = (Dali::Renderer *)jarg2;
36573   if (!arg2) {
36574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36575     return 0;
36576   }
36577   {
36578     try {
36579       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36580     } catch (std::out_of_range& e) {
36581       {
36582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36583       };
36584     } catch (std::exception& e) {
36585       {
36586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36587       };
36588     } catch (Dali::DaliException e) {
36589       {
36590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36591       };
36592     } catch (...) {
36593       {
36594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36595       };
36596     }
36597   }
36598
36599   jresult = result;
36600   return jresult;
36601 }
36602
36603
36604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36605   unsigned int jresult ;
36606   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36607   unsigned int result;
36608
36609   arg1 = (Dali::Actor *)jarg1;
36610   {
36611     try {
36612       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36613     } catch (std::out_of_range& e) {
36614       {
36615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36616       };
36617     } catch (std::exception& e) {
36618       {
36619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36620       };
36621     } catch (Dali::DaliException e) {
36622       {
36623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36624       };
36625     } catch (...) {
36626       {
36627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36628       };
36629     }
36630   }
36631
36632   jresult = result;
36633   return jresult;
36634 }
36635
36636
36637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36638   void * jresult ;
36639   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36640   unsigned int arg2 ;
36641   Dali::Renderer result;
36642
36643   arg1 = (Dali::Actor *)jarg1;
36644   arg2 = (unsigned int)jarg2;
36645   {
36646     try {
36647       result = (arg1)->GetRendererAt(arg2);
36648     } catch (std::out_of_range& e) {
36649       {
36650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36651       };
36652     } catch (std::exception& e) {
36653       {
36654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36655       };
36656     } catch (Dali::DaliException e) {
36657       {
36658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36659       };
36660     } catch (...) {
36661       {
36662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36663       };
36664     }
36665   }
36666
36667   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36668   return jresult;
36669 }
36670
36671
36672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36674   Dali::Renderer *arg2 = 0 ;
36675
36676   arg1 = (Dali::Actor *)jarg1;
36677   arg2 = (Dali::Renderer *)jarg2;
36678   if (!arg2) {
36679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36680     return ;
36681   }
36682   {
36683     try {
36684       (arg1)->RemoveRenderer(*arg2);
36685     } catch (std::out_of_range& e) {
36686       {
36687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36688       };
36689     } catch (std::exception& e) {
36690       {
36691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36692       };
36693     } catch (Dali::DaliException e) {
36694       {
36695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36696       };
36697     } catch (...) {
36698       {
36699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36700       };
36701     }
36702   }
36703
36704 }
36705
36706
36707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36708   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36709   unsigned int arg2 ;
36710
36711   arg1 = (Dali::Actor *)jarg1;
36712   arg2 = (unsigned int)jarg2;
36713   {
36714     try {
36715       (arg1)->RemoveRenderer(arg2);
36716     } catch (std::out_of_range& e) {
36717       {
36718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36719       };
36720     } catch (std::exception& e) {
36721       {
36722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36723       };
36724     } catch (Dali::DaliException e) {
36725       {
36726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36727       };
36728     } catch (...) {
36729       {
36730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36731       };
36732     }
36733   }
36734
36735 }
36736
36737
36738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36739   void * jresult ;
36740   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36741   Dali::Actor::TouchSignalType *result = 0 ;
36742
36743   arg1 = (Dali::Actor *)jarg1;
36744   {
36745     try {
36746       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36747     } catch (std::out_of_range& e) {
36748       {
36749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36750       };
36751     } catch (std::exception& e) {
36752       {
36753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36754       };
36755     } catch (Dali::DaliException e) {
36756       {
36757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36758       };
36759     } catch (...) {
36760       {
36761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36762       };
36763     }
36764   }
36765
36766   jresult = (void *)result;
36767   return jresult;
36768 }
36769
36770
36771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36772   void * jresult ;
36773   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36774   Dali::Actor::TouchDataSignalType *result = 0 ;
36775
36776   arg1 = (Dali::Actor *)jarg1;
36777   {
36778     try {
36779       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36780     } catch (std::out_of_range& e) {
36781       {
36782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36783       };
36784     } catch (std::exception& e) {
36785       {
36786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36787       };
36788     } catch (Dali::DaliException e) {
36789       {
36790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36791       };
36792     } catch (...) {
36793       {
36794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36795       };
36796     }
36797   }
36798
36799   jresult = (void *)result;
36800   return jresult;
36801 }
36802
36803
36804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36805   void * jresult ;
36806   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36807   Dali::Actor::HoverSignalType *result = 0 ;
36808
36809   arg1 = (Dali::Actor *)jarg1;
36810   {
36811     try {
36812       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36813     } catch (std::out_of_range& e) {
36814       {
36815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36816       };
36817     } catch (std::exception& e) {
36818       {
36819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36820       };
36821     } catch (Dali::DaliException e) {
36822       {
36823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36824       };
36825     } catch (...) {
36826       {
36827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36828       };
36829     }
36830   }
36831
36832   jresult = (void *)result;
36833   return jresult;
36834 }
36835
36836
36837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36838   void * jresult ;
36839   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36840   Dali::Actor::WheelEventSignalType *result = 0 ;
36841
36842   arg1 = (Dali::Actor *)jarg1;
36843   {
36844     try {
36845       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36846     } catch (std::out_of_range& e) {
36847       {
36848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36849       };
36850     } catch (std::exception& e) {
36851       {
36852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36853       };
36854     } catch (Dali::DaliException e) {
36855       {
36856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36857       };
36858     } catch (...) {
36859       {
36860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36861       };
36862     }
36863   }
36864
36865   jresult = (void *)result;
36866   return jresult;
36867 }
36868
36869
36870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
36871   void * jresult ;
36872   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36873   Dali::Actor::OnStageSignalType *result = 0 ;
36874
36875   arg1 = (Dali::Actor *)jarg1;
36876   {
36877     try {
36878       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
36879     } catch (std::out_of_range& e) {
36880       {
36881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36882       };
36883     } catch (std::exception& e) {
36884       {
36885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36886       };
36887     } catch (Dali::DaliException e) {
36888       {
36889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36890       };
36891     } catch (...) {
36892       {
36893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36894       };
36895     }
36896   }
36897
36898   jresult = (void *)result;
36899   return jresult;
36900 }
36901
36902
36903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
36904   void * jresult ;
36905   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36906   Dali::Actor::OffStageSignalType *result = 0 ;
36907
36908   arg1 = (Dali::Actor *)jarg1;
36909   {
36910     try {
36911       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
36912     } catch (std::out_of_range& e) {
36913       {
36914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36915       };
36916     } catch (std::exception& e) {
36917       {
36918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36919       };
36920     } catch (Dali::DaliException e) {
36921       {
36922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36923       };
36924     } catch (...) {
36925       {
36926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36927       };
36928     }
36929   }
36930
36931   jresult = (void *)result;
36932   return jresult;
36933 }
36934
36935
36936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36937   void * jresult ;
36938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36939   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36940
36941   arg1 = (Dali::Actor *)jarg1;
36942   {
36943     try {
36944       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36945     } catch (std::out_of_range& e) {
36946       {
36947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36948       };
36949     } catch (std::exception& e) {
36950       {
36951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36952       };
36953     } catch (Dali::DaliException e) {
36954       {
36955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36956       };
36957     } catch (...) {
36958       {
36959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36960       };
36961     }
36962   }
36963
36964   jresult = (void *)result;
36965   return jresult;
36966 }
36967
36968
36969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
36970   Dali::Actor *arg1 = 0 ;
36971
36972   arg1 = (Dali::Actor *)jarg1;
36973   if (!arg1) {
36974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36975     return ;
36976   }
36977   {
36978     try {
36979       Dali::UnparentAndReset(*arg1);
36980     } catch (std::out_of_range& e) {
36981       {
36982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36983       };
36984     } catch (std::exception& e) {
36985       {
36986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36987       };
36988     } catch (Dali::DaliException e) {
36989       {
36990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36991       };
36992     } catch (...) {
36993       {
36994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36995       };
36996     }
36997   }
36998
36999 }
37000
37001
37002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37003   int jresult ;
37004   int result;
37005
37006   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37007   jresult = (int)result;
37008   return jresult;
37009 }
37010
37011
37012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37013   int jresult ;
37014   int result;
37015
37016   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37017   jresult = (int)result;
37018   return jresult;
37019 }
37020
37021
37022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37023   int jresult ;
37024   int result;
37025
37026   result = (int)Dali::Layer::Property::BEHAVIOR;
37027   jresult = (int)result;
37028   return jresult;
37029 }
37030
37031
37032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37033   void * jresult ;
37034   Dali::Layer::Property *result = 0 ;
37035
37036   {
37037     try {
37038       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37039     } catch (std::out_of_range& e) {
37040       {
37041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37042       };
37043     } catch (std::exception& e) {
37044       {
37045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37046       };
37047     } catch (Dali::DaliException e) {
37048       {
37049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37050       };
37051     } catch (...) {
37052       {
37053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37054       };
37055     }
37056   }
37057
37058   jresult = (void *)result;
37059   return jresult;
37060 }
37061
37062
37063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37064   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37065
37066   arg1 = (Dali::Layer::Property *)jarg1;
37067   {
37068     try {
37069       delete arg1;
37070     } catch (std::out_of_range& e) {
37071       {
37072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37073       };
37074     } catch (std::exception& e) {
37075       {
37076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37077       };
37078     } catch (Dali::DaliException e) {
37079       {
37080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37081       };
37082     } catch (...) {
37083       {
37084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37085       };
37086     }
37087   }
37088
37089 }
37090
37091
37092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37093   void * jresult ;
37094   Dali::Layer *result = 0 ;
37095
37096   {
37097     try {
37098       result = (Dali::Layer *)new Dali::Layer();
37099     } catch (std::out_of_range& e) {
37100       {
37101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37102       };
37103     } catch (std::exception& e) {
37104       {
37105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37106       };
37107     } catch (Dali::DaliException e) {
37108       {
37109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37110       };
37111     } catch (...) {
37112       {
37113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37114       };
37115     }
37116   }
37117
37118   jresult = (void *)result;
37119   return jresult;
37120 }
37121
37122
37123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37124   void * jresult ;
37125   Dali::Layer result;
37126
37127   {
37128     try {
37129       result = Dali::Layer::New();
37130     } catch (std::out_of_range& e) {
37131       {
37132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37133       };
37134     } catch (std::exception& e) {
37135       {
37136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37137       };
37138     } catch (Dali::DaliException e) {
37139       {
37140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37141       };
37142     } catch (...) {
37143       {
37144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37145       };
37146     }
37147   }
37148
37149   jresult = new Dali::Layer((const Dali::Layer &)result);
37150   return jresult;
37151 }
37152
37153
37154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37155   void * jresult ;
37156   Dali::BaseHandle arg1 ;
37157   Dali::BaseHandle *argp1 ;
37158   Dali::Layer result;
37159
37160   argp1 = (Dali::BaseHandle *)jarg1;
37161   if (!argp1) {
37162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37163     return 0;
37164   }
37165   arg1 = *argp1;
37166   {
37167     try {
37168       result = Dali::Layer::DownCast(arg1);
37169     } catch (std::out_of_range& e) {
37170       {
37171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37172       };
37173     } catch (std::exception& e) {
37174       {
37175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37176       };
37177     } catch (Dali::DaliException e) {
37178       {
37179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37180       };
37181     } catch (...) {
37182       {
37183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37184       };
37185     }
37186   }
37187
37188   jresult = new Dali::Layer((const Dali::Layer &)result);
37189   return jresult;
37190 }
37191
37192
37193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37194   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37195
37196   arg1 = (Dali::Layer *)jarg1;
37197   {
37198     try {
37199       delete arg1;
37200     } catch (std::out_of_range& e) {
37201       {
37202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37203       };
37204     } catch (std::exception& e) {
37205       {
37206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37207       };
37208     } catch (Dali::DaliException e) {
37209       {
37210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37211       };
37212     } catch (...) {
37213       {
37214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37215       };
37216     }
37217   }
37218
37219 }
37220
37221
37222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37223   void * jresult ;
37224   Dali::Layer *arg1 = 0 ;
37225   Dali::Layer *result = 0 ;
37226
37227   arg1 = (Dali::Layer *)jarg1;
37228   if (!arg1) {
37229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37230     return 0;
37231   }
37232   {
37233     try {
37234       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37235     } catch (std::out_of_range& e) {
37236       {
37237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37238       };
37239     } catch (std::exception& e) {
37240       {
37241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37242       };
37243     } catch (Dali::DaliException e) {
37244       {
37245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37246       };
37247     } catch (...) {
37248       {
37249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37250       };
37251     }
37252   }
37253
37254   jresult = (void *)result;
37255   return jresult;
37256 }
37257
37258
37259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37260   void * jresult ;
37261   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37262   Dali::Layer *arg2 = 0 ;
37263   Dali::Layer *result = 0 ;
37264
37265   arg1 = (Dali::Layer *)jarg1;
37266   arg2 = (Dali::Layer *)jarg2;
37267   if (!arg2) {
37268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37269     return 0;
37270   }
37271   {
37272     try {
37273       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37274     } catch (std::out_of_range& e) {
37275       {
37276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37277       };
37278     } catch (std::exception& e) {
37279       {
37280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37281       };
37282     } catch (Dali::DaliException e) {
37283       {
37284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37285       };
37286     } catch (...) {
37287       {
37288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37289       };
37290     }
37291   }
37292
37293   jresult = (void *)result;
37294   return jresult;
37295 }
37296
37297
37298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37299   unsigned int jresult ;
37300   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37301   unsigned int result;
37302
37303   arg1 = (Dali::Layer *)jarg1;
37304   {
37305     try {
37306       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37307     } catch (std::out_of_range& e) {
37308       {
37309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37310       };
37311     } catch (std::exception& e) {
37312       {
37313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37314       };
37315     } catch (Dali::DaliException e) {
37316       {
37317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37318       };
37319     } catch (...) {
37320       {
37321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37322       };
37323     }
37324   }
37325
37326   jresult = result;
37327   return jresult;
37328 }
37329
37330
37331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37332   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37333
37334   arg1 = (Dali::Layer *)jarg1;
37335   {
37336     try {
37337       (arg1)->Raise();
37338     } catch (std::out_of_range& e) {
37339       {
37340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37341       };
37342     } catch (std::exception& e) {
37343       {
37344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37345       };
37346     } catch (Dali::DaliException e) {
37347       {
37348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37349       };
37350     } catch (...) {
37351       {
37352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37353       };
37354     }
37355   }
37356
37357 }
37358
37359
37360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37361   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37362
37363   arg1 = (Dali::Layer *)jarg1;
37364   {
37365     try {
37366       (arg1)->Lower();
37367     } catch (std::out_of_range& e) {
37368       {
37369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37370       };
37371     } catch (std::exception& e) {
37372       {
37373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37374       };
37375     } catch (Dali::DaliException e) {
37376       {
37377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37378       };
37379     } catch (...) {
37380       {
37381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37382       };
37383     }
37384   }
37385
37386 }
37387
37388
37389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37390   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37391   Dali::Layer arg2 ;
37392   Dali::Layer *argp2 ;
37393
37394   arg1 = (Dali::Layer *)jarg1;
37395   argp2 = (Dali::Layer *)jarg2;
37396   if (!argp2) {
37397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37398     return ;
37399   }
37400   arg2 = *argp2;
37401   {
37402     try {
37403       (arg1)->RaiseAbove(arg2);
37404     } catch (std::out_of_range& e) {
37405       {
37406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37407       };
37408     } catch (std::exception& e) {
37409       {
37410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37411       };
37412     } catch (Dali::DaliException e) {
37413       {
37414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37415       };
37416     } catch (...) {
37417       {
37418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37419       };
37420     }
37421   }
37422
37423 }
37424
37425
37426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37427   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37428   Dali::Layer arg2 ;
37429   Dali::Layer *argp2 ;
37430
37431   arg1 = (Dali::Layer *)jarg1;
37432   argp2 = (Dali::Layer *)jarg2;
37433   if (!argp2) {
37434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37435     return ;
37436   }
37437   arg2 = *argp2;
37438   {
37439     try {
37440       (arg1)->LowerBelow(arg2);
37441     } catch (std::out_of_range& e) {
37442       {
37443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37444       };
37445     } catch (std::exception& e) {
37446       {
37447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37448       };
37449     } catch (Dali::DaliException e) {
37450       {
37451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37452       };
37453     } catch (...) {
37454       {
37455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37456       };
37457     }
37458   }
37459
37460 }
37461
37462
37463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37464   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37465
37466   arg1 = (Dali::Layer *)jarg1;
37467   {
37468     try {
37469       (arg1)->RaiseToTop();
37470     } catch (std::out_of_range& e) {
37471       {
37472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37473       };
37474     } catch (std::exception& e) {
37475       {
37476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37477       };
37478     } catch (Dali::DaliException e) {
37479       {
37480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37481       };
37482     } catch (...) {
37483       {
37484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37485       };
37486     }
37487   }
37488
37489 }
37490
37491
37492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37493   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37494
37495   arg1 = (Dali::Layer *)jarg1;
37496   {
37497     try {
37498       (arg1)->LowerToBottom();
37499     } catch (std::out_of_range& e) {
37500       {
37501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37502       };
37503     } catch (std::exception& e) {
37504       {
37505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37506       };
37507     } catch (Dali::DaliException e) {
37508       {
37509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37510       };
37511     } catch (...) {
37512       {
37513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37514       };
37515     }
37516   }
37517
37518 }
37519
37520
37521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37522   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37523   Dali::Layer arg2 ;
37524   Dali::Layer *argp2 ;
37525
37526   arg1 = (Dali::Layer *)jarg1;
37527   argp2 = (Dali::Layer *)jarg2;
37528   if (!argp2) {
37529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37530     return ;
37531   }
37532   arg2 = *argp2;
37533   {
37534     try {
37535       (arg1)->MoveAbove(arg2);
37536     } catch (std::out_of_range& e) {
37537       {
37538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37539       };
37540     } catch (std::exception& e) {
37541       {
37542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37543       };
37544     } catch (Dali::DaliException e) {
37545       {
37546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37547       };
37548     } catch (...) {
37549       {
37550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37551       };
37552     }
37553   }
37554
37555 }
37556
37557
37558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37559   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37560   Dali::Layer arg2 ;
37561   Dali::Layer *argp2 ;
37562
37563   arg1 = (Dali::Layer *)jarg1;
37564   argp2 = (Dali::Layer *)jarg2;
37565   if (!argp2) {
37566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37567     return ;
37568   }
37569   arg2 = *argp2;
37570   {
37571     try {
37572       (arg1)->MoveBelow(arg2);
37573     } catch (std::out_of_range& e) {
37574       {
37575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37576       };
37577     } catch (std::exception& e) {
37578       {
37579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37580       };
37581     } catch (Dali::DaliException e) {
37582       {
37583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37584       };
37585     } catch (...) {
37586       {
37587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37588       };
37589     }
37590   }
37591
37592 }
37593
37594
37595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37596   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37597   Dali::Layer::Behavior arg2 ;
37598
37599   arg1 = (Dali::Layer *)jarg1;
37600   arg2 = (Dali::Layer::Behavior)jarg2;
37601   {
37602     try {
37603       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37604     } catch (std::out_of_range& e) {
37605       {
37606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37607       };
37608     } catch (std::exception& e) {
37609       {
37610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37611       };
37612     } catch (Dali::DaliException e) {
37613       {
37614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37615       };
37616     } catch (...) {
37617       {
37618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37619       };
37620     }
37621   }
37622
37623 }
37624
37625
37626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37627   int jresult ;
37628   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37629   Dali::Layer::Behavior result;
37630
37631   arg1 = (Dali::Layer *)jarg1;
37632   {
37633     try {
37634       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37635     } catch (std::out_of_range& e) {
37636       {
37637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37638       };
37639     } catch (std::exception& e) {
37640       {
37641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37642       };
37643     } catch (Dali::DaliException e) {
37644       {
37645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37646       };
37647     } catch (...) {
37648       {
37649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37650       };
37651     }
37652   }
37653
37654   jresult = (int)result;
37655   return jresult;
37656 }
37657
37658
37659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37660   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37661   bool arg2 ;
37662
37663   arg1 = (Dali::Layer *)jarg1;
37664   arg2 = jarg2 ? true : false;
37665   {
37666     try {
37667       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37668     } catch (std::out_of_range& e) {
37669       {
37670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37671       };
37672     } catch (std::exception& e) {
37673       {
37674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37675       };
37676     } catch (Dali::DaliException e) {
37677       {
37678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37679       };
37680     } catch (...) {
37681       {
37682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37683       };
37684     }
37685   }
37686
37687 }
37688
37689
37690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37691   unsigned int jresult ;
37692   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37693   bool result;
37694
37695   arg1 = (Dali::Layer *)jarg1;
37696   {
37697     try {
37698       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37699     } catch (std::out_of_range& e) {
37700       {
37701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37702       };
37703     } catch (std::exception& e) {
37704       {
37705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37706       };
37707     } catch (Dali::DaliException e) {
37708       {
37709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37710       };
37711     } catch (...) {
37712       {
37713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37714       };
37715     }
37716   }
37717
37718   jresult = result;
37719   return jresult;
37720 }
37721
37722
37723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37724   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37725   int arg2 ;
37726   int arg3 ;
37727   int arg4 ;
37728   int arg5 ;
37729
37730   arg1 = (Dali::Layer *)jarg1;
37731   arg2 = (int)jarg2;
37732   arg3 = (int)jarg3;
37733   arg4 = (int)jarg4;
37734   arg5 = (int)jarg5;
37735   {
37736     try {
37737       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37738     } catch (std::out_of_range& e) {
37739       {
37740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37741       };
37742     } catch (std::exception& e) {
37743       {
37744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37745       };
37746     } catch (Dali::DaliException e) {
37747       {
37748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37749       };
37750     } catch (...) {
37751       {
37752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37753       };
37754     }
37755   }
37756
37757 }
37758
37759
37760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37761   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37762   Dali::ClippingBox arg2 ;
37763   Dali::ClippingBox *argp2 ;
37764
37765   arg1 = (Dali::Layer *)jarg1;
37766   argp2 = (Dali::ClippingBox *)jarg2;
37767   if (!argp2) {
37768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37769     return ;
37770   }
37771   arg2 = *argp2;
37772   {
37773     try {
37774       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37775     } catch (std::out_of_range& e) {
37776       {
37777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37778       };
37779     } catch (std::exception& e) {
37780       {
37781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37782       };
37783     } catch (Dali::DaliException e) {
37784       {
37785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37786       };
37787     } catch (...) {
37788       {
37789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37790       };
37791     }
37792   }
37793
37794 }
37795
37796
37797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37798   void * jresult ;
37799   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37800   Dali::ClippingBox result;
37801
37802   arg1 = (Dali::Layer *)jarg1;
37803   {
37804     try {
37805       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37806     } catch (std::out_of_range& e) {
37807       {
37808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37809       };
37810     } catch (std::exception& e) {
37811       {
37812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37813       };
37814     } catch (Dali::DaliException e) {
37815       {
37816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37817       };
37818     } catch (...) {
37819       {
37820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37821       };
37822     }
37823   }
37824
37825   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37826   return jresult;
37827 }
37828
37829
37830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37831   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37832   bool arg2 ;
37833
37834   arg1 = (Dali::Layer *)jarg1;
37835   arg2 = jarg2 ? true : false;
37836   {
37837     try {
37838       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37839     } catch (std::out_of_range& e) {
37840       {
37841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37842       };
37843     } catch (std::exception& e) {
37844       {
37845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37846       };
37847     } catch (Dali::DaliException e) {
37848       {
37849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37850       };
37851     } catch (...) {
37852       {
37853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37854       };
37855     }
37856   }
37857
37858 }
37859
37860
37861 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37862   unsigned int jresult ;
37863   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37864   bool result;
37865
37866   arg1 = (Dali::Layer *)jarg1;
37867   {
37868     try {
37869       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37870     } catch (std::out_of_range& e) {
37871       {
37872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37873       };
37874     } catch (std::exception& e) {
37875       {
37876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37877       };
37878     } catch (Dali::DaliException e) {
37879       {
37880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37881       };
37882     } catch (...) {
37883       {
37884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37885       };
37886     }
37887   }
37888
37889   jresult = result;
37890   return jresult;
37891 }
37892
37893
37894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37895   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37896   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37897
37898   arg1 = (Dali::Layer *)jarg1;
37899   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37900   {
37901     try {
37902       (arg1)->SetSortFunction(arg2);
37903     } catch (std::out_of_range& e) {
37904       {
37905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37906       };
37907     } catch (std::exception& e) {
37908       {
37909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37910       };
37911     } catch (Dali::DaliException e) {
37912       {
37913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37914       };
37915     } catch (...) {
37916       {
37917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37918       };
37919     }
37920   }
37921
37922 }
37923
37924
37925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37926   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37927   bool arg2 ;
37928
37929   arg1 = (Dali::Layer *)jarg1;
37930   arg2 = jarg2 ? true : false;
37931   {
37932     try {
37933       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
37934     } catch (std::out_of_range& e) {
37935       {
37936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37937       };
37938     } catch (std::exception& e) {
37939       {
37940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37941       };
37942     } catch (Dali::DaliException e) {
37943       {
37944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37945       };
37946     } catch (...) {
37947       {
37948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37949       };
37950     }
37951   }
37952
37953 }
37954
37955
37956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
37957   unsigned int jresult ;
37958   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37959   bool result;
37960
37961   arg1 = (Dali::Layer *)jarg1;
37962   {
37963     try {
37964       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
37965     } catch (std::out_of_range& e) {
37966       {
37967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37968       };
37969     } catch (std::exception& e) {
37970       {
37971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37972       };
37973     } catch (Dali::DaliException e) {
37974       {
37975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37976       };
37977     } catch (...) {
37978       {
37979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37980       };
37981     }
37982   }
37983
37984   jresult = result;
37985   return jresult;
37986 }
37987
37988
37989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
37990   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37991   bool arg2 ;
37992
37993   arg1 = (Dali::Layer *)jarg1;
37994   arg2 = jarg2 ? true : false;
37995   {
37996     try {
37997       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
37998     } catch (std::out_of_range& e) {
37999       {
38000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38001       };
38002     } catch (std::exception& e) {
38003       {
38004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38005       };
38006     } catch (Dali::DaliException e) {
38007       {
38008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38009       };
38010     } catch (...) {
38011       {
38012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38013       };
38014     }
38015   }
38016
38017 }
38018
38019
38020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38021   unsigned int jresult ;
38022   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38023   bool result;
38024
38025   arg1 = (Dali::Layer *)jarg1;
38026   {
38027     try {
38028       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
38029     } catch (std::out_of_range& e) {
38030       {
38031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38032       };
38033     } catch (std::exception& e) {
38034       {
38035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38036       };
38037     } catch (Dali::DaliException e) {
38038       {
38039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38040       };
38041     } catch (...) {
38042       {
38043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38044       };
38045     }
38046   }
38047
38048   jresult = result;
38049   return jresult;
38050 }
38051
38052
38053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38054   void * jresult ;
38055   Dali::Vector4 *result = 0 ;
38056
38057   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38058   jresult = (void *)result;
38059   return jresult;
38060 }
38061
38062
38063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38064   void * jresult ;
38065   Dali::Vector4 *result = 0 ;
38066
38067   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38068   jresult = (void *)result;
38069   return jresult;
38070 }
38071
38072
38073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38074   void * jresult ;
38075   Dali::Stage *result = 0 ;
38076
38077   {
38078     try {
38079       result = (Dali::Stage *)new Dali::Stage();
38080     } catch (std::out_of_range& e) {
38081       {
38082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38083       };
38084     } catch (std::exception& e) {
38085       {
38086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38087       };
38088     } catch (Dali::DaliException e) {
38089       {
38090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38091       };
38092     } catch (...) {
38093       {
38094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38095       };
38096     }
38097   }
38098
38099   jresult = (void *)result;
38100   return jresult;
38101 }
38102
38103
38104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38105   void * jresult ;
38106   Dali::Stage result;
38107
38108   {
38109     try {
38110       result = Dali::Stage::GetCurrent();
38111     } catch (std::out_of_range& e) {
38112       {
38113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38114       };
38115     } catch (std::exception& e) {
38116       {
38117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38118       };
38119     } catch (Dali::DaliException e) {
38120       {
38121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38122       };
38123     } catch (...) {
38124       {
38125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38126       };
38127     }
38128   }
38129
38130   jresult = new Dali::Stage((const Dali::Stage &)result);
38131   return jresult;
38132 }
38133
38134
38135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38136   unsigned int jresult ;
38137   bool result;
38138
38139   {
38140     try {
38141       result = (bool)Dali::Stage::IsInstalled();
38142     } catch (std::out_of_range& e) {
38143       {
38144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38145       };
38146     } catch (std::exception& e) {
38147       {
38148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38149       };
38150     } catch (Dali::DaliException e) {
38151       {
38152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38153       };
38154     } catch (...) {
38155       {
38156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38157       };
38158     }
38159   }
38160
38161   jresult = result;
38162   return jresult;
38163 }
38164
38165
38166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38167   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38168
38169   arg1 = (Dali::Stage *)jarg1;
38170   {
38171     try {
38172       delete arg1;
38173     } catch (std::out_of_range& e) {
38174       {
38175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38176       };
38177     } catch (std::exception& e) {
38178       {
38179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38180       };
38181     } catch (Dali::DaliException e) {
38182       {
38183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38184       };
38185     } catch (...) {
38186       {
38187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38188       };
38189     }
38190   }
38191
38192 }
38193
38194
38195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38196   void * jresult ;
38197   Dali::Stage *arg1 = 0 ;
38198   Dali::Stage *result = 0 ;
38199
38200   arg1 = (Dali::Stage *)jarg1;
38201   if (!arg1) {
38202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38203     return 0;
38204   }
38205   {
38206     try {
38207       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38208     } catch (std::out_of_range& e) {
38209       {
38210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38211       };
38212     } catch (std::exception& e) {
38213       {
38214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38215       };
38216     } catch (Dali::DaliException e) {
38217       {
38218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38219       };
38220     } catch (...) {
38221       {
38222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38223       };
38224     }
38225   }
38226
38227   jresult = (void *)result;
38228   return jresult;
38229 }
38230
38231
38232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38233   void * jresult ;
38234   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38235   Dali::Stage *arg2 = 0 ;
38236   Dali::Stage *result = 0 ;
38237
38238   arg1 = (Dali::Stage *)jarg1;
38239   arg2 = (Dali::Stage *)jarg2;
38240   if (!arg2) {
38241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38242     return 0;
38243   }
38244   {
38245     try {
38246       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38247     } catch (std::out_of_range& e) {
38248       {
38249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38250       };
38251     } catch (std::exception& e) {
38252       {
38253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38254       };
38255     } catch (Dali::DaliException e) {
38256       {
38257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38258       };
38259     } catch (...) {
38260       {
38261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38262       };
38263     }
38264   }
38265
38266   jresult = (void *)result;
38267   return jresult;
38268 }
38269
38270
38271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38272   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38273   Dali::Actor *arg2 = 0 ;
38274
38275   arg1 = (Dali::Stage *)jarg1;
38276   arg2 = (Dali::Actor *)jarg2;
38277   if (!arg2) {
38278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38279     return ;
38280   }
38281   {
38282     try {
38283       (arg1)->Add(*arg2);
38284     } catch (std::out_of_range& e) {
38285       {
38286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38287       };
38288     } catch (std::exception& e) {
38289       {
38290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38291       };
38292     } catch (Dali::DaliException e) {
38293       {
38294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38295       };
38296     } catch (...) {
38297       {
38298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38299       };
38300     }
38301   }
38302
38303 }
38304
38305
38306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38307   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38308   Dali::Actor *arg2 = 0 ;
38309
38310   arg1 = (Dali::Stage *)jarg1;
38311   arg2 = (Dali::Actor *)jarg2;
38312   if (!arg2) {
38313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38314     return ;
38315   }
38316   {
38317     try {
38318       (arg1)->Remove(*arg2);
38319     } catch (std::out_of_range& e) {
38320       {
38321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38322       };
38323     } catch (std::exception& e) {
38324       {
38325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38326       };
38327     } catch (Dali::DaliException e) {
38328       {
38329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38330       };
38331     } catch (...) {
38332       {
38333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38334       };
38335     }
38336   }
38337
38338 }
38339
38340
38341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38342   void * jresult ;
38343   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38344   Dali::Vector2 result;
38345
38346   arg1 = (Dali::Stage *)jarg1;
38347   {
38348     try {
38349       result = ((Dali::Stage const *)arg1)->GetSize();
38350     } catch (std::out_of_range& e) {
38351       {
38352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38353       };
38354     } catch (std::exception& e) {
38355       {
38356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38357       };
38358     } catch (Dali::DaliException e) {
38359       {
38360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38361       };
38362     } catch (...) {
38363       {
38364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38365       };
38366     }
38367   }
38368
38369   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38370   return jresult;
38371 }
38372
38373
38374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38375   void * jresult ;
38376   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38377   Dali::RenderTaskList result;
38378
38379   arg1 = (Dali::Stage *)jarg1;
38380   {
38381     try {
38382       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38383     } catch (std::out_of_range& e) {
38384       {
38385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38386       };
38387     } catch (std::exception& e) {
38388       {
38389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38390       };
38391     } catch (Dali::DaliException e) {
38392       {
38393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38394       };
38395     } catch (...) {
38396       {
38397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38398       };
38399     }
38400   }
38401
38402   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38403   return jresult;
38404 }
38405
38406
38407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38408   unsigned int jresult ;
38409   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38410   unsigned int result;
38411
38412   arg1 = (Dali::Stage *)jarg1;
38413   {
38414     try {
38415       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38416     } catch (std::out_of_range& e) {
38417       {
38418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38419       };
38420     } catch (std::exception& e) {
38421       {
38422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38423       };
38424     } catch (Dali::DaliException e) {
38425       {
38426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38427       };
38428     } catch (...) {
38429       {
38430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38431       };
38432     }
38433   }
38434
38435   jresult = result;
38436   return jresult;
38437 }
38438
38439
38440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38441   void * jresult ;
38442   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38443   unsigned int arg2 ;
38444   Dali::Layer result;
38445
38446   arg1 = (Dali::Stage *)jarg1;
38447   arg2 = (unsigned int)jarg2;
38448   {
38449     try {
38450       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38451     } catch (std::out_of_range& e) {
38452       {
38453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38454       };
38455     } catch (std::exception& e) {
38456       {
38457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38458       };
38459     } catch (Dali::DaliException e) {
38460       {
38461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38462       };
38463     } catch (...) {
38464       {
38465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38466       };
38467     }
38468   }
38469
38470   jresult = new Dali::Layer((const Dali::Layer &)result);
38471   return jresult;
38472 }
38473
38474
38475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38476   void * jresult ;
38477   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38478   Dali::Layer result;
38479
38480   arg1 = (Dali::Stage *)jarg1;
38481   {
38482     try {
38483       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38484     } catch (std::out_of_range& e) {
38485       {
38486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38487       };
38488     } catch (std::exception& e) {
38489       {
38490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38491       };
38492     } catch (Dali::DaliException e) {
38493       {
38494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38495       };
38496     } catch (...) {
38497       {
38498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38499       };
38500     }
38501   }
38502
38503   jresult = new Dali::Layer((const Dali::Layer &)result);
38504   return jresult;
38505 }
38506
38507
38508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38509   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38510   Dali::Vector4 arg2 ;
38511   Dali::Vector4 *argp2 ;
38512
38513   arg1 = (Dali::Stage *)jarg1;
38514   argp2 = (Dali::Vector4 *)jarg2;
38515   if (!argp2) {
38516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38517     return ;
38518   }
38519   arg2 = *argp2;
38520   {
38521     try {
38522       (arg1)->SetBackgroundColor(arg2);
38523     } catch (std::out_of_range& e) {
38524       {
38525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38526       };
38527     } catch (std::exception& e) {
38528       {
38529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38530       };
38531     } catch (Dali::DaliException e) {
38532       {
38533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38534       };
38535     } catch (...) {
38536       {
38537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38538       };
38539     }
38540   }
38541
38542 }
38543
38544
38545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38546   void * jresult ;
38547   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38548   Dali::Vector4 result;
38549
38550   arg1 = (Dali::Stage *)jarg1;
38551   {
38552     try {
38553       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38554     } catch (std::out_of_range& e) {
38555       {
38556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38557       };
38558     } catch (std::exception& e) {
38559       {
38560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38561       };
38562     } catch (Dali::DaliException e) {
38563       {
38564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38565       };
38566     } catch (...) {
38567       {
38568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38569       };
38570     }
38571   }
38572
38573   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38574   return jresult;
38575 }
38576
38577
38578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38579   void * jresult ;
38580   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38581   Dali::Vector2 result;
38582
38583   arg1 = (Dali::Stage *)jarg1;
38584   {
38585     try {
38586       result = ((Dali::Stage const *)arg1)->GetDpi();
38587     } catch (std::out_of_range& e) {
38588       {
38589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38590       };
38591     } catch (std::exception& e) {
38592       {
38593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38594       };
38595     } catch (Dali::DaliException e) {
38596       {
38597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38598       };
38599     } catch (...) {
38600       {
38601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38602       };
38603     }
38604   }
38605
38606   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38607   return jresult;
38608 }
38609
38610
38611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38612   void * jresult ;
38613   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38614   Dali::ObjectRegistry result;
38615
38616   arg1 = (Dali::Stage *)jarg1;
38617   {
38618     try {
38619       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38620     } catch (std::out_of_range& e) {
38621       {
38622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38623       };
38624     } catch (std::exception& e) {
38625       {
38626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38627       };
38628     } catch (Dali::DaliException e) {
38629       {
38630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38631       };
38632     } catch (...) {
38633       {
38634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38635       };
38636     }
38637   }
38638
38639   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38640   return jresult;
38641 }
38642
38643
38644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38645   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38646   float arg2 ;
38647
38648   arg1 = (Dali::Stage *)jarg1;
38649   arg2 = (float)jarg2;
38650   {
38651     try {
38652       (arg1)->KeepRendering(arg2);
38653     } catch (std::out_of_range& e) {
38654       {
38655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38656       };
38657     } catch (std::exception& e) {
38658       {
38659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38660       };
38661     } catch (Dali::DaliException e) {
38662       {
38663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38664       };
38665     } catch (...) {
38666       {
38667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38668       };
38669     }
38670   }
38671
38672 }
38673
38674
38675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38676   void * jresult ;
38677   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38678   Dali::Stage::KeyEventSignalType *result = 0 ;
38679
38680   arg1 = (Dali::Stage *)jarg1;
38681   {
38682     try {
38683       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38684     } catch (std::out_of_range& e) {
38685       {
38686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38687       };
38688     } catch (std::exception& e) {
38689       {
38690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38691       };
38692     } catch (Dali::DaliException e) {
38693       {
38694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38695       };
38696     } catch (...) {
38697       {
38698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38699       };
38700     }
38701   }
38702
38703   jresult = (void *)result;
38704   return jresult;
38705 }
38706
38707
38708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38709   void * jresult ;
38710   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38711   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38712
38713   arg1 = (Dali::Stage *)jarg1;
38714   {
38715     try {
38716       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38717     } catch (std::out_of_range& e) {
38718       {
38719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38720       };
38721     } catch (std::exception& e) {
38722       {
38723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38724       };
38725     } catch (Dali::DaliException e) {
38726       {
38727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38728       };
38729     } catch (...) {
38730       {
38731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38732       };
38733     }
38734   }
38735
38736   jresult = (void *)result;
38737   return jresult;
38738 }
38739
38740
38741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38742   void * jresult ;
38743   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38744   Dali::Stage::TouchSignalType *result = 0 ;
38745
38746   arg1 = (Dali::Stage *)jarg1;
38747   {
38748     try {
38749       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38750     } catch (std::out_of_range& e) {
38751       {
38752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38753       };
38754     } catch (std::exception& e) {
38755       {
38756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38757       };
38758     } catch (Dali::DaliException e) {
38759       {
38760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38761       };
38762     } catch (...) {
38763       {
38764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38765       };
38766     }
38767   }
38768
38769   jresult = (void *)result;
38770   return jresult;
38771 }
38772
38773
38774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38775   void * jresult ;
38776   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38777   Dali::Stage::WheelEventSignalType *result = 0 ;
38778
38779   arg1 = (Dali::Stage *)jarg1;
38780   {
38781     try {
38782       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38783     } catch (std::out_of_range& e) {
38784       {
38785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38786       };
38787     } catch (std::exception& e) {
38788       {
38789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38790       };
38791     } catch (Dali::DaliException e) {
38792       {
38793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38794       };
38795     } catch (...) {
38796       {
38797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38798       };
38799     }
38800   }
38801
38802   jresult = (void *)result;
38803   return jresult;
38804 }
38805
38806
38807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38808   void * jresult ;
38809   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38810   Dali::Stage::ContextStatusSignal *result = 0 ;
38811
38812   arg1 = (Dali::Stage *)jarg1;
38813   {
38814     try {
38815       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38816     } catch (std::out_of_range& e) {
38817       {
38818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38819       };
38820     } catch (std::exception& e) {
38821       {
38822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38823       };
38824     } catch (Dali::DaliException e) {
38825       {
38826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38827       };
38828     } catch (...) {
38829       {
38830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38831       };
38832     }
38833   }
38834
38835   jresult = (void *)result;
38836   return jresult;
38837 }
38838
38839
38840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38841   void * jresult ;
38842   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38843   Dali::Stage::ContextStatusSignal *result = 0 ;
38844
38845   arg1 = (Dali::Stage *)jarg1;
38846   {
38847     try {
38848       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38849     } catch (std::out_of_range& e) {
38850       {
38851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38852       };
38853     } catch (std::exception& e) {
38854       {
38855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38856       };
38857     } catch (Dali::DaliException e) {
38858       {
38859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38860       };
38861     } catch (...) {
38862       {
38863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38864       };
38865     }
38866   }
38867
38868   jresult = (void *)result;
38869   return jresult;
38870 }
38871
38872
38873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38874   void * jresult ;
38875   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38876   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38877
38878   arg1 = (Dali::Stage *)jarg1;
38879   {
38880     try {
38881       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38882     } catch (std::out_of_range& e) {
38883       {
38884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38885       };
38886     } catch (std::exception& e) {
38887       {
38888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38889       };
38890     } catch (Dali::DaliException e) {
38891       {
38892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38893       };
38894     } catch (...) {
38895       {
38896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38897       };
38898     }
38899   }
38900
38901   jresult = (void *)result;
38902   return jresult;
38903 }
38904
38905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38906   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38907   Dali::DevelStage::Rendering arg2 ;
38908
38909   arg1 = (Dali::Stage *)jarg1;
38910   arg2 = (Dali::DevelStage::Rendering)jarg2;
38911   {
38912     try {
38913       DevelStage::SetRenderingBehavior(*arg1,arg2);
38914     } catch (std::out_of_range& e) {
38915       {
38916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38917       };
38918     } catch (std::exception& e) {
38919       {
38920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38921       };
38922     } catch (Dali::DaliException e) {
38923       {
38924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38925       };
38926     } catch (...) {
38927       {
38928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38929       };
38930     }
38931   }
38932
38933 }
38934
38935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38936
38937   int jresult ;
38938   int result ;
38939   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38940
38941   arg1 = (Dali::Stage *)jarg1;
38942   {
38943     try {
38944       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38945     } catch (std::out_of_range& e) {
38946       {
38947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38948       };
38949     } catch (std::exception& e) {
38950       {
38951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38952       };
38953     } catch (Dali::DaliException e) {
38954       {
38955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38956       };
38957     } catch (...) {
38958       {
38959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38960       };
38961     }
38962   }
38963
38964   jresult = result;
38965   return jresult;
38966 }
38967
38968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38969   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38970
38971   arg1 = (Dali::RelayoutContainer *)jarg1;
38972   {
38973     try {
38974       delete arg1;
38975     } catch (std::out_of_range& e) {
38976       {
38977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38978       };
38979     } catch (std::exception& e) {
38980       {
38981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38982       };
38983     } catch (Dali::DaliException e) {
38984       {
38985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38986       };
38987     } catch (...) {
38988       {
38989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38990       };
38991     }
38992   }
38993
38994 }
38995
38996
38997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38998   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38999   Dali::Actor *arg2 = 0 ;
39000   Dali::Vector2 *arg3 = 0 ;
39001
39002   arg1 = (Dali::RelayoutContainer *)jarg1;
39003   arg2 = (Dali::Actor *)jarg2;
39004   if (!arg2) {
39005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39006     return ;
39007   }
39008   arg3 = (Dali::Vector2 *)jarg3;
39009   if (!arg3) {
39010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39011     return ;
39012   }
39013   {
39014     try {
39015       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39016     } catch (std::out_of_range& e) {
39017       {
39018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39019       };
39020     } catch (std::exception& e) {
39021       {
39022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39023       };
39024     } catch (Dali::DaliException e) {
39025       {
39026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39027       };
39028     } catch (...) {
39029       {
39030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39031       };
39032     }
39033   }
39034
39035 }
39036
39037
39038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39039   void * jresult ;
39040   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39041   Dali::CustomActor result;
39042
39043   arg1 = (Dali::CustomActorImpl *)jarg1;
39044   {
39045     try {
39046       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39047     } catch (std::out_of_range& e) {
39048       {
39049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39050       };
39051     } catch (std::exception& e) {
39052       {
39053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39054       };
39055     } catch (Dali::DaliException e) {
39056       {
39057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39058       };
39059     } catch (...) {
39060       {
39061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39062       };
39063     }
39064   }
39065
39066   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39067   return jresult;
39068 }
39069
39070
39071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39072   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39073   int arg2 ;
39074
39075   arg1 = (Dali::CustomActorImpl *)jarg1;
39076   arg2 = (int)jarg2;
39077   {
39078     try {
39079       (arg1)->OnStageConnection(arg2);
39080     } catch (std::out_of_range& e) {
39081       {
39082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39083       };
39084     } catch (std::exception& e) {
39085       {
39086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39087       };
39088     } catch (Dali::DaliException e) {
39089       {
39090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39091       };
39092     } catch (...) {
39093       {
39094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39095       };
39096     }
39097   }
39098
39099 }
39100
39101
39102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39103   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39104
39105   arg1 = (Dali::CustomActorImpl *)jarg1;
39106   {
39107     try {
39108       (arg1)->OnStageDisconnection();
39109     } catch (std::out_of_range& e) {
39110       {
39111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39112       };
39113     } catch (std::exception& e) {
39114       {
39115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39116       };
39117     } catch (Dali::DaliException e) {
39118       {
39119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39120       };
39121     } catch (...) {
39122       {
39123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39124       };
39125     }
39126   }
39127
39128 }
39129
39130
39131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39132   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39133   Dali::Actor *arg2 = 0 ;
39134
39135   arg1 = (Dali::CustomActorImpl *)jarg1;
39136   arg2 = (Dali::Actor *)jarg2;
39137   if (!arg2) {
39138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39139     return ;
39140   }
39141   {
39142     try {
39143       (arg1)->OnChildAdd(*arg2);
39144     } catch (std::out_of_range& e) {
39145       {
39146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39147       };
39148     } catch (std::exception& e) {
39149       {
39150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39151       };
39152     } catch (Dali::DaliException e) {
39153       {
39154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39155       };
39156     } catch (...) {
39157       {
39158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39159       };
39160     }
39161   }
39162
39163 }
39164
39165
39166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39167   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39168   Dali::Actor *arg2 = 0 ;
39169
39170   arg1 = (Dali::CustomActorImpl *)jarg1;
39171   arg2 = (Dali::Actor *)jarg2;
39172   if (!arg2) {
39173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39174     return ;
39175   }
39176   {
39177     try {
39178       (arg1)->OnChildRemove(*arg2);
39179     } catch (std::out_of_range& e) {
39180       {
39181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39182       };
39183     } catch (std::exception& e) {
39184       {
39185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39186       };
39187     } catch (Dali::DaliException e) {
39188       {
39189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39190       };
39191     } catch (...) {
39192       {
39193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39194       };
39195     }
39196   }
39197
39198 }
39199
39200
39201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39202   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39203   Dali::Property::Index arg2 ;
39204   Dali::Property::Value arg3 ;
39205   Dali::Property::Value *argp3 ;
39206
39207   arg1 = (Dali::CustomActorImpl *)jarg1;
39208   arg2 = (Dali::Property::Index)jarg2;
39209   argp3 = (Dali::Property::Value *)jarg3;
39210   if (!argp3) {
39211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39212     return ;
39213   }
39214   arg3 = *argp3;
39215   {
39216     try {
39217       (arg1)->OnPropertySet(arg2,arg3);
39218     } catch (std::out_of_range& e) {
39219       {
39220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39221       };
39222     } catch (std::exception& e) {
39223       {
39224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39225       };
39226     } catch (Dali::DaliException e) {
39227       {
39228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39229       };
39230     } catch (...) {
39231       {
39232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39233       };
39234     }
39235   }
39236
39237 }
39238
39239
39240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39241   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39242   Dali::Vector3 *arg2 = 0 ;
39243
39244   arg1 = (Dali::CustomActorImpl *)jarg1;
39245   arg2 = (Dali::Vector3 *)jarg2;
39246   if (!arg2) {
39247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39248     return ;
39249   }
39250   {
39251     try {
39252       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39253     } catch (std::out_of_range& e) {
39254       {
39255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39256       };
39257     } catch (std::exception& e) {
39258       {
39259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39260       };
39261     } catch (Dali::DaliException e) {
39262       {
39263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39264       };
39265     } catch (...) {
39266       {
39267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39268       };
39269     }
39270   }
39271
39272 }
39273
39274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39275   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39276   Dali::Animation *arg2 = 0 ;
39277   Dali::Vector3 *arg3 = 0 ;
39278
39279   arg1 = (Dali::CustomActorImpl *)jarg1;
39280   arg2 = (Dali::Animation *)jarg2;
39281   if (!arg2) {
39282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39283     return ;
39284   }
39285   arg3 = (Dali::Vector3 *)jarg3;
39286   if (!arg3) {
39287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39288     return ;
39289   }
39290   {
39291     try {
39292       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39293     } catch (std::out_of_range& e) {
39294       {
39295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39296       };
39297     } catch (std::exception& e) {
39298       {
39299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39300       };
39301     } catch (Dali::DaliException e) {
39302       {
39303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39304       };
39305     } catch (...) {
39306       {
39307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39308       };
39309     }
39310   }
39311
39312 }
39313
39314
39315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39316   unsigned int jresult ;
39317   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39318   Dali::TouchEvent *arg2 = 0 ;
39319   bool result;
39320
39321   arg1 = (Dali::CustomActorImpl *)jarg1;
39322   arg2 = (Dali::TouchEvent *)jarg2;
39323   if (!arg2) {
39324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39325     return 0;
39326   }
39327   {
39328     try {
39329       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39330     } catch (std::out_of_range& e) {
39331       {
39332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39333       };
39334     } catch (std::exception& e) {
39335       {
39336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39337       };
39338     } catch (Dali::DaliException e) {
39339       {
39340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39341       };
39342     } catch (...) {
39343       {
39344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39345       };
39346     }
39347   }
39348
39349   jresult = result;
39350   return jresult;
39351 }
39352
39353
39354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39355   unsigned int jresult ;
39356   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39357   Dali::HoverEvent *arg2 = 0 ;
39358   bool result;
39359
39360   arg1 = (Dali::CustomActorImpl *)jarg1;
39361   arg2 = (Dali::HoverEvent *)jarg2;
39362   if (!arg2) {
39363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39364     return 0;
39365   }
39366   {
39367     try {
39368       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39369     } catch (std::out_of_range& e) {
39370       {
39371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39372       };
39373     } catch (std::exception& e) {
39374       {
39375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39376       };
39377     } catch (Dali::DaliException e) {
39378       {
39379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39380       };
39381     } catch (...) {
39382       {
39383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39384       };
39385     }
39386   }
39387
39388   jresult = result;
39389   return jresult;
39390 }
39391
39392
39393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39394   unsigned int jresult ;
39395   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39396   Dali::KeyEvent *arg2 = 0 ;
39397   bool result;
39398
39399   arg1 = (Dali::CustomActorImpl *)jarg1;
39400   arg2 = (Dali::KeyEvent *)jarg2;
39401   if (!arg2) {
39402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39403     return 0;
39404   }
39405   {
39406     try {
39407       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39408     } catch (std::out_of_range& e) {
39409       {
39410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39411       };
39412     } catch (std::exception& e) {
39413       {
39414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39415       };
39416     } catch (Dali::DaliException e) {
39417       {
39418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39419       };
39420     } catch (...) {
39421       {
39422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39423       };
39424     }
39425   }
39426
39427   jresult = result;
39428   return jresult;
39429 }
39430
39431
39432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39433   unsigned int jresult ;
39434   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39435   Dali::WheelEvent *arg2 = 0 ;
39436   bool result;
39437
39438   arg1 = (Dali::CustomActorImpl *)jarg1;
39439   arg2 = (Dali::WheelEvent *)jarg2;
39440   if (!arg2) {
39441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39442     return 0;
39443   }
39444   {
39445     try {
39446       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39447     } catch (std::out_of_range& e) {
39448       {
39449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39450       };
39451     } catch (std::exception& e) {
39452       {
39453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39454       };
39455     } catch (Dali::DaliException e) {
39456       {
39457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39458       };
39459     } catch (...) {
39460       {
39461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39462       };
39463     }
39464   }
39465
39466   jresult = result;
39467   return jresult;
39468 }
39469
39470
39471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39472   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39473   Dali::Vector2 *arg2 = 0 ;
39474   Dali::RelayoutContainer *arg3 = 0 ;
39475
39476   arg1 = (Dali::CustomActorImpl *)jarg1;
39477   arg2 = (Dali::Vector2 *)jarg2;
39478   if (!arg2) {
39479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39480     return ;
39481   }
39482   arg3 = (Dali::RelayoutContainer *)jarg3;
39483   if (!arg3) {
39484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39485     return ;
39486   }
39487   {
39488     try {
39489       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39490     } catch (std::out_of_range& e) {
39491       {
39492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39493       };
39494     } catch (std::exception& e) {
39495       {
39496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39497       };
39498     } catch (Dali::DaliException e) {
39499       {
39500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39501       };
39502     } catch (...) {
39503       {
39504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39505       };
39506     }
39507   }
39508
39509 }
39510
39511
39512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39513   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39514   Dali::ResizePolicy::Type arg2 ;
39515   Dali::Dimension::Type arg3 ;
39516
39517   arg1 = (Dali::CustomActorImpl *)jarg1;
39518   arg2 = (Dali::ResizePolicy::Type)jarg2;
39519   arg3 = (Dali::Dimension::Type)jarg3;
39520   {
39521     try {
39522       (arg1)->OnSetResizePolicy(arg2,arg3);
39523     } catch (std::out_of_range& e) {
39524       {
39525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39526       };
39527     } catch (std::exception& e) {
39528       {
39529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39530       };
39531     } catch (Dali::DaliException e) {
39532       {
39533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39534       };
39535     } catch (...) {
39536       {
39537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39538       };
39539     }
39540   }
39541
39542 }
39543
39544
39545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39546   void * jresult ;
39547   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39548   Dali::Vector3 result;
39549
39550   arg1 = (Dali::CustomActorImpl *)jarg1;
39551   {
39552     try {
39553       result = (arg1)->GetNaturalSize();
39554     } catch (std::out_of_range& e) {
39555       {
39556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39557       };
39558     } catch (std::exception& e) {
39559       {
39560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39561       };
39562     } catch (Dali::DaliException e) {
39563       {
39564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39565       };
39566     } catch (...) {
39567       {
39568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39569       };
39570     }
39571   }
39572
39573   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39574   return jresult;
39575 }
39576
39577
39578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39579   float jresult ;
39580   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39581   Dali::Actor *arg2 = 0 ;
39582   Dali::Dimension::Type arg3 ;
39583   float result;
39584
39585   arg1 = (Dali::CustomActorImpl *)jarg1;
39586   arg2 = (Dali::Actor *)jarg2;
39587   if (!arg2) {
39588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39589     return 0;
39590   }
39591   arg3 = (Dali::Dimension::Type)jarg3;
39592   {
39593     try {
39594       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39595     } catch (std::out_of_range& e) {
39596       {
39597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39598       };
39599     } catch (std::exception& e) {
39600       {
39601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39602       };
39603     } catch (Dali::DaliException e) {
39604       {
39605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39606       };
39607     } catch (...) {
39608       {
39609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39610       };
39611     }
39612   }
39613
39614   jresult = result;
39615   return jresult;
39616 }
39617
39618
39619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39620   float jresult ;
39621   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39622   float arg2 ;
39623   float result;
39624
39625   arg1 = (Dali::CustomActorImpl *)jarg1;
39626   arg2 = (float)jarg2;
39627   {
39628     try {
39629       result = (float)(arg1)->GetHeightForWidth(arg2);
39630     } catch (std::out_of_range& e) {
39631       {
39632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39633       };
39634     } catch (std::exception& e) {
39635       {
39636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39637       };
39638     } catch (Dali::DaliException e) {
39639       {
39640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39641       };
39642     } catch (...) {
39643       {
39644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39645       };
39646     }
39647   }
39648
39649   jresult = result;
39650   return jresult;
39651 }
39652
39653
39654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39655   float jresult ;
39656   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39657   float arg2 ;
39658   float result;
39659
39660   arg1 = (Dali::CustomActorImpl *)jarg1;
39661   arg2 = (float)jarg2;
39662   {
39663     try {
39664       result = (float)(arg1)->GetWidthForHeight(arg2);
39665     } catch (std::out_of_range& e) {
39666       {
39667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39668       };
39669     } catch (std::exception& e) {
39670       {
39671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39672       };
39673     } catch (Dali::DaliException e) {
39674       {
39675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39676       };
39677     } catch (...) {
39678       {
39679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39680       };
39681     }
39682   }
39683
39684   jresult = result;
39685   return jresult;
39686 }
39687
39688
39689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39690   unsigned int jresult ;
39691   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39692   Dali::Dimension::Type arg2 ;
39693   bool result;
39694
39695   arg1 = (Dali::CustomActorImpl *)jarg1;
39696   arg2 = (Dali::Dimension::Type)jarg2;
39697   {
39698     try {
39699       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39700     } catch (std::out_of_range& e) {
39701       {
39702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39703       };
39704     } catch (std::exception& e) {
39705       {
39706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39707       };
39708     } catch (Dali::DaliException e) {
39709       {
39710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39711       };
39712     } catch (...) {
39713       {
39714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39715       };
39716     }
39717   }
39718
39719   jresult = result;
39720   return jresult;
39721 }
39722
39723
39724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39725   unsigned int jresult ;
39726   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39727   bool result;
39728
39729   arg1 = (Dali::CustomActorImpl *)jarg1;
39730   {
39731     try {
39732       result = (bool)(arg1)->RelayoutDependentOnChildren();
39733     } catch (std::out_of_range& e) {
39734       {
39735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39736       };
39737     } catch (std::exception& e) {
39738       {
39739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39740       };
39741     } catch (Dali::DaliException e) {
39742       {
39743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39744       };
39745     } catch (...) {
39746       {
39747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39748       };
39749     }
39750   }
39751
39752   jresult = result;
39753   return jresult;
39754 }
39755
39756
39757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39758   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39759   Dali::Dimension::Type arg2 ;
39760
39761   arg1 = (Dali::CustomActorImpl *)jarg1;
39762   arg2 = (Dali::Dimension::Type)jarg2;
39763   {
39764     try {
39765       (arg1)->OnCalculateRelayoutSize(arg2);
39766     } catch (std::out_of_range& e) {
39767       {
39768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39769       };
39770     } catch (std::exception& e) {
39771       {
39772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39773       };
39774     } catch (Dali::DaliException e) {
39775       {
39776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39777       };
39778     } catch (...) {
39779       {
39780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39781       };
39782     }
39783   }
39784
39785 }
39786
39787
39788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39789   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39790   float arg2 ;
39791   Dali::Dimension::Type arg3 ;
39792
39793   arg1 = (Dali::CustomActorImpl *)jarg1;
39794   arg2 = (float)jarg2;
39795   arg3 = (Dali::Dimension::Type)jarg3;
39796   {
39797     try {
39798       (arg1)->OnLayoutNegotiated(arg2,arg3);
39799     } catch (std::out_of_range& e) {
39800       {
39801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39802       };
39803     } catch (std::exception& e) {
39804       {
39805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39806       };
39807     } catch (Dali::DaliException e) {
39808       {
39809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39810       };
39811     } catch (...) {
39812       {
39813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39814       };
39815     }
39816   }
39817
39818 }
39819
39820
39821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39822   unsigned int jresult ;
39823   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39824   bool result;
39825
39826   arg1 = (Dali::CustomActorImpl *)jarg1;
39827   {
39828     try {
39829       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39830     } catch (std::out_of_range& e) {
39831       {
39832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39833       };
39834     } catch (std::exception& e) {
39835       {
39836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39837       };
39838     } catch (Dali::DaliException e) {
39839       {
39840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39841       };
39842     } catch (...) {
39843       {
39844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39845       };
39846     }
39847   }
39848
39849   jresult = result;
39850   return jresult;
39851 }
39852
39853
39854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39855   unsigned int jresult ;
39856   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39857   bool result;
39858
39859   arg1 = (Dali::CustomActorImpl *)jarg1;
39860   {
39861     try {
39862       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39863     } catch (std::out_of_range& e) {
39864       {
39865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39866       };
39867     } catch (std::exception& e) {
39868       {
39869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39870       };
39871     } catch (Dali::DaliException e) {
39872       {
39873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39874       };
39875     } catch (...) {
39876       {
39877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39878       };
39879     }
39880   }
39881
39882   jresult = result;
39883   return jresult;
39884 }
39885
39886
39887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39888   unsigned int jresult ;
39889   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39890   bool result;
39891
39892   arg1 = (Dali::CustomActorImpl *)jarg1;
39893   {
39894     try {
39895       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39896     } catch (std::out_of_range& e) {
39897       {
39898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39899       };
39900     } catch (std::exception& e) {
39901       {
39902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39903       };
39904     } catch (Dali::DaliException e) {
39905       {
39906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39907       };
39908     } catch (...) {
39909       {
39910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39911       };
39912     }
39913   }
39914
39915   jresult = result;
39916   return jresult;
39917 }
39918
39919
39920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39921   unsigned int jresult ;
39922   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39923   bool result;
39924
39925   arg1 = (Dali::CustomActorImpl *)jarg1;
39926   {
39927     try {
39928       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39929     } catch (std::out_of_range& e) {
39930       {
39931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39932       };
39933     } catch (std::exception& e) {
39934       {
39935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39936       };
39937     } catch (Dali::DaliException e) {
39938       {
39939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39940       };
39941     } catch (...) {
39942       {
39943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39944       };
39945     }
39946   }
39947
39948   jresult = result;
39949   return jresult;
39950 }
39951
39952
39953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39954   void * jresult ;
39955   Dali::CustomActor *result = 0 ;
39956
39957   {
39958     try {
39959       result = (Dali::CustomActor *)new Dali::CustomActor();
39960     } catch (std::out_of_range& e) {
39961       {
39962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39963       };
39964     } catch (std::exception& e) {
39965       {
39966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39967       };
39968     } catch (Dali::DaliException e) {
39969       {
39970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39971       };
39972     } catch (...) {
39973       {
39974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39975       };
39976     }
39977   }
39978
39979   jresult = (void *)result;
39980   return jresult;
39981 }
39982
39983
39984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39985   void * jresult ;
39986   Dali::BaseHandle arg1 ;
39987   Dali::BaseHandle *argp1 ;
39988   Dali::CustomActor result;
39989
39990   argp1 = (Dali::BaseHandle *)jarg1;
39991   if (!argp1) {
39992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39993     return 0;
39994   }
39995   arg1 = *argp1;
39996   {
39997     try {
39998       result = Dali::CustomActor::DownCast(arg1);
39999     } catch (std::out_of_range& e) {
40000       {
40001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40002       };
40003     } catch (std::exception& e) {
40004       {
40005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40006       };
40007     } catch (Dali::DaliException e) {
40008       {
40009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40010       };
40011     } catch (...) {
40012       {
40013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40014       };
40015     }
40016   }
40017
40018   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40019   return jresult;
40020 }
40021
40022
40023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40024   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40025
40026   arg1 = (Dali::CustomActor *)jarg1;
40027   {
40028     try {
40029       delete arg1;
40030     } catch (std::out_of_range& e) {
40031       {
40032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40033       };
40034     } catch (std::exception& e) {
40035       {
40036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40037       };
40038     } catch (Dali::DaliException e) {
40039       {
40040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40041       };
40042     } catch (...) {
40043       {
40044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40045       };
40046     }
40047   }
40048
40049 }
40050
40051
40052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40053   void * jresult ;
40054   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40055   Dali::CustomActorImpl *result = 0 ;
40056
40057   arg1 = (Dali::CustomActor *)jarg1;
40058   {
40059     try {
40060       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40061     } catch (std::out_of_range& e) {
40062       {
40063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40064       };
40065     } catch (std::exception& e) {
40066       {
40067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40068       };
40069     } catch (Dali::DaliException e) {
40070       {
40071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40072       };
40073     } catch (...) {
40074       {
40075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40076       };
40077     }
40078   }
40079
40080   jresult = (void *)result;
40081   return jresult;
40082 }
40083
40084
40085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40086   void * jresult ;
40087   Dali::CustomActorImpl *arg1 = 0 ;
40088   Dali::CustomActor *result = 0 ;
40089
40090   arg1 = (Dali::CustomActorImpl *)jarg1;
40091   if (!arg1) {
40092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40093     return 0;
40094   }
40095   {
40096     try {
40097       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40098     } catch (std::out_of_range& e) {
40099       {
40100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40101       };
40102     } catch (std::exception& e) {
40103       {
40104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40105       };
40106     } catch (Dali::DaliException e) {
40107       {
40108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40109       };
40110     } catch (...) {
40111       {
40112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40113       };
40114     }
40115   }
40116
40117   jresult = (void *)result;
40118   return jresult;
40119 }
40120
40121
40122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40123   void * jresult ;
40124   Dali::CustomActor *arg1 = 0 ;
40125   Dali::CustomActor *result = 0 ;
40126
40127   arg1 = (Dali::CustomActor *)jarg1;
40128   if (!arg1) {
40129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40130     return 0;
40131   }
40132   {
40133     try {
40134       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40135     } catch (std::out_of_range& e) {
40136       {
40137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40138       };
40139     } catch (std::exception& e) {
40140       {
40141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40142       };
40143     } catch (Dali::DaliException e) {
40144       {
40145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40146       };
40147     } catch (...) {
40148       {
40149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40150       };
40151     }
40152   }
40153
40154   jresult = (void *)result;
40155   return jresult;
40156 }
40157
40158
40159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40160   void * jresult ;
40161   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40162   Dali::CustomActor *arg2 = 0 ;
40163   Dali::CustomActor *result = 0 ;
40164
40165   arg1 = (Dali::CustomActor *)jarg1;
40166   arg2 = (Dali::CustomActor *)jarg2;
40167   if (!arg2) {
40168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40169     return 0;
40170   }
40171   {
40172     try {
40173       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40174     } catch (std::out_of_range& e) {
40175       {
40176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40177       };
40178     } catch (std::exception& e) {
40179       {
40180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40181       };
40182     } catch (Dali::DaliException e) {
40183       {
40184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40185       };
40186     } catch (...) {
40187       {
40188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40189       };
40190     }
40191   }
40192
40193   jresult = (void *)result;
40194   return jresult;
40195 }
40196
40197
40198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40199   int jresult ;
40200   int result;
40201
40202   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40203   jresult = (int)result;
40204   return jresult;
40205 }
40206
40207
40208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40209   int jresult ;
40210   int result;
40211
40212   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40213   jresult = (int)result;
40214   return jresult;
40215 }
40216
40217
40218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40219   int jresult ;
40220   int result;
40221
40222   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40223   jresult = (int)result;
40224   return jresult;
40225 }
40226
40227
40228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40229   int jresult ;
40230   int result;
40231
40232   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40233   jresult = (int)result;
40234   return jresult;
40235 }
40236
40237
40238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40239   int jresult ;
40240   int result;
40241
40242   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40243   jresult = (int)result;
40244   return jresult;
40245 }
40246
40247
40248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40249   int jresult ;
40250   int result;
40251
40252   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40253   jresult = (int)result;
40254   return jresult;
40255 }
40256
40257
40258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40259   int jresult ;
40260   int result;
40261
40262   result = (int)Dali::PanGestureDetector::Property::PANNING;
40263   jresult = (int)result;
40264   return jresult;
40265 }
40266
40267
40268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40269   void * jresult ;
40270   Dali::PanGestureDetector::Property *result = 0 ;
40271
40272   {
40273     try {
40274       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40275     } catch (std::out_of_range& e) {
40276       {
40277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40278       };
40279     } catch (std::exception& e) {
40280       {
40281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40282       };
40283     } catch (Dali::DaliException e) {
40284       {
40285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40286       };
40287     } catch (...) {
40288       {
40289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40290       };
40291     }
40292   }
40293
40294   jresult = (void *)result;
40295   return jresult;
40296 }
40297
40298
40299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40300   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40301
40302   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40303   {
40304     try {
40305       delete arg1;
40306     } catch (std::out_of_range& e) {
40307       {
40308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40309       };
40310     } catch (std::exception& e) {
40311       {
40312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40313       };
40314     } catch (Dali::DaliException e) {
40315       {
40316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40317       };
40318     } catch (...) {
40319       {
40320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40321       };
40322     }
40323   }
40324
40325 }
40326
40327
40328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40329   void * jresult ;
40330   Dali::Radian *result = 0 ;
40331
40332   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40333   jresult = (void *)result;
40334   return jresult;
40335 }
40336
40337
40338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40339   void * jresult ;
40340   Dali::Radian *result = 0 ;
40341
40342   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40343   jresult = (void *)result;
40344   return jresult;
40345 }
40346
40347
40348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40349   void * jresult ;
40350   Dali::Radian *result = 0 ;
40351
40352   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40353   jresult = (void *)result;
40354   return jresult;
40355 }
40356
40357
40358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40359   void * jresult ;
40360   Dali::Radian *result = 0 ;
40361
40362   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40363   jresult = (void *)result;
40364   return jresult;
40365 }
40366
40367
40368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40369   void * jresult ;
40370   Dali::Radian *result = 0 ;
40371
40372   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40373   jresult = (void *)result;
40374   return jresult;
40375 }
40376
40377
40378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40379   void * jresult ;
40380   Dali::Radian *result = 0 ;
40381
40382   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40383   jresult = (void *)result;
40384   return jresult;
40385 }
40386
40387
40388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40389   void * jresult ;
40390   Dali::Radian *result = 0 ;
40391
40392   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40393   jresult = (void *)result;
40394   return jresult;
40395 }
40396
40397
40398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40399   void * jresult ;
40400   Dali::PanGestureDetector *result = 0 ;
40401
40402   {
40403     try {
40404       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40405     } catch (std::out_of_range& e) {
40406       {
40407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40408       };
40409     } catch (std::exception& e) {
40410       {
40411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40412       };
40413     } catch (Dali::DaliException e) {
40414       {
40415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40416       };
40417     } catch (...) {
40418       {
40419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40420       };
40421     }
40422   }
40423
40424   jresult = (void *)result;
40425   return jresult;
40426 }
40427
40428
40429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40430   void * jresult ;
40431   Dali::PanGestureDetector result;
40432
40433   {
40434     try {
40435       result = Dali::PanGestureDetector::New();
40436     } catch (std::out_of_range& e) {
40437       {
40438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40439       };
40440     } catch (std::exception& e) {
40441       {
40442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40443       };
40444     } catch (Dali::DaliException e) {
40445       {
40446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40447       };
40448     } catch (...) {
40449       {
40450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40451       };
40452     }
40453   }
40454
40455   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40456   return jresult;
40457 }
40458
40459
40460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40461   void * jresult ;
40462   Dali::BaseHandle arg1 ;
40463   Dali::BaseHandle *argp1 ;
40464   Dali::PanGestureDetector result;
40465
40466   argp1 = (Dali::BaseHandle *)jarg1;
40467   if (!argp1) {
40468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40469     return 0;
40470   }
40471   arg1 = *argp1;
40472   {
40473     try {
40474       result = Dali::PanGestureDetector::DownCast(arg1);
40475     } catch (std::out_of_range& e) {
40476       {
40477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40478       };
40479     } catch (std::exception& e) {
40480       {
40481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40482       };
40483     } catch (Dali::DaliException e) {
40484       {
40485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40486       };
40487     } catch (...) {
40488       {
40489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40490       };
40491     }
40492   }
40493
40494   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40495   return jresult;
40496 }
40497
40498
40499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40500   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40501
40502   arg1 = (Dali::PanGestureDetector *)jarg1;
40503   {
40504     try {
40505       delete arg1;
40506     } catch (std::out_of_range& e) {
40507       {
40508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40509       };
40510     } catch (std::exception& e) {
40511       {
40512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40513       };
40514     } catch (Dali::DaliException e) {
40515       {
40516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40517       };
40518     } catch (...) {
40519       {
40520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40521       };
40522     }
40523   }
40524
40525 }
40526
40527
40528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40529   void * jresult ;
40530   Dali::PanGestureDetector *arg1 = 0 ;
40531   Dali::PanGestureDetector *result = 0 ;
40532
40533   arg1 = (Dali::PanGestureDetector *)jarg1;
40534   if (!arg1) {
40535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40536     return 0;
40537   }
40538   {
40539     try {
40540       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40541     } catch (std::out_of_range& e) {
40542       {
40543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40544       };
40545     } catch (std::exception& e) {
40546       {
40547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40548       };
40549     } catch (Dali::DaliException e) {
40550       {
40551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40552       };
40553     } catch (...) {
40554       {
40555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40556       };
40557     }
40558   }
40559
40560   jresult = (void *)result;
40561   return jresult;
40562 }
40563
40564
40565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40566   void * jresult ;
40567   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40568   Dali::PanGestureDetector *arg2 = 0 ;
40569   Dali::PanGestureDetector *result = 0 ;
40570
40571   arg1 = (Dali::PanGestureDetector *)jarg1;
40572   arg2 = (Dali::PanGestureDetector *)jarg2;
40573   if (!arg2) {
40574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40575     return 0;
40576   }
40577   {
40578     try {
40579       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40580     } catch (std::out_of_range& e) {
40581       {
40582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40583       };
40584     } catch (std::exception& e) {
40585       {
40586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40587       };
40588     } catch (Dali::DaliException e) {
40589       {
40590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40591       };
40592     } catch (...) {
40593       {
40594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40595       };
40596     }
40597   }
40598
40599   jresult = (void *)result;
40600   return jresult;
40601 }
40602
40603
40604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40605   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40606   unsigned int arg2 ;
40607
40608   arg1 = (Dali::PanGestureDetector *)jarg1;
40609   arg2 = (unsigned int)jarg2;
40610   {
40611     try {
40612       (arg1)->SetMinimumTouchesRequired(arg2);
40613     } catch (std::out_of_range& e) {
40614       {
40615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40616       };
40617     } catch (std::exception& e) {
40618       {
40619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40620       };
40621     } catch (Dali::DaliException e) {
40622       {
40623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40624       };
40625     } catch (...) {
40626       {
40627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40628       };
40629     }
40630   }
40631
40632 }
40633
40634
40635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40636   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40637   unsigned int arg2 ;
40638
40639   arg1 = (Dali::PanGestureDetector *)jarg1;
40640   arg2 = (unsigned int)jarg2;
40641   {
40642     try {
40643       (arg1)->SetMaximumTouchesRequired(arg2);
40644     } catch (std::out_of_range& e) {
40645       {
40646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40647       };
40648     } catch (std::exception& e) {
40649       {
40650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40651       };
40652     } catch (Dali::DaliException e) {
40653       {
40654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40655       };
40656     } catch (...) {
40657       {
40658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40659       };
40660     }
40661   }
40662
40663 }
40664
40665
40666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40667   unsigned int jresult ;
40668   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40669   unsigned int result;
40670
40671   arg1 = (Dali::PanGestureDetector *)jarg1;
40672   {
40673     try {
40674       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40675     } catch (std::out_of_range& e) {
40676       {
40677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40678       };
40679     } catch (std::exception& e) {
40680       {
40681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40682       };
40683     } catch (Dali::DaliException e) {
40684       {
40685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40686       };
40687     } catch (...) {
40688       {
40689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40690       };
40691     }
40692   }
40693
40694   jresult = result;
40695   return jresult;
40696 }
40697
40698
40699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40700   unsigned int jresult ;
40701   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40702   unsigned int result;
40703
40704   arg1 = (Dali::PanGestureDetector *)jarg1;
40705   {
40706     try {
40707       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40708     } catch (std::out_of_range& e) {
40709       {
40710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40711       };
40712     } catch (std::exception& e) {
40713       {
40714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40715       };
40716     } catch (Dali::DaliException e) {
40717       {
40718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40719       };
40720     } catch (...) {
40721       {
40722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40723       };
40724     }
40725   }
40726
40727   jresult = result;
40728   return jresult;
40729 }
40730
40731
40732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40733   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40734   Dali::Radian arg2 ;
40735   Dali::Radian arg3 ;
40736   Dali::Radian *argp2 ;
40737   Dali::Radian *argp3 ;
40738
40739   arg1 = (Dali::PanGestureDetector *)jarg1;
40740   argp2 = (Dali::Radian *)jarg2;
40741   if (!argp2) {
40742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40743     return ;
40744   }
40745   arg2 = *argp2;
40746   argp3 = (Dali::Radian *)jarg3;
40747   if (!argp3) {
40748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40749     return ;
40750   }
40751   arg3 = *argp3;
40752   {
40753     try {
40754       (arg1)->AddAngle(arg2,arg3);
40755     } catch (std::out_of_range& e) {
40756       {
40757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40758       };
40759     } catch (std::exception& e) {
40760       {
40761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40762       };
40763     } catch (Dali::DaliException e) {
40764       {
40765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40766       };
40767     } catch (...) {
40768       {
40769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40770       };
40771     }
40772   }
40773
40774 }
40775
40776
40777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40778   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40779   Dali::Radian arg2 ;
40780   Dali::Radian *argp2 ;
40781
40782   arg1 = (Dali::PanGestureDetector *)jarg1;
40783   argp2 = (Dali::Radian *)jarg2;
40784   if (!argp2) {
40785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40786     return ;
40787   }
40788   arg2 = *argp2;
40789   {
40790     try {
40791       (arg1)->AddAngle(arg2);
40792     } catch (std::out_of_range& e) {
40793       {
40794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40795       };
40796     } catch (std::exception& e) {
40797       {
40798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40799       };
40800     } catch (Dali::DaliException e) {
40801       {
40802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40803       };
40804     } catch (...) {
40805       {
40806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40807       };
40808     }
40809   }
40810
40811 }
40812
40813
40814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40815   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40816   Dali::Radian arg2 ;
40817   Dali::Radian arg3 ;
40818   Dali::Radian *argp2 ;
40819   Dali::Radian *argp3 ;
40820
40821   arg1 = (Dali::PanGestureDetector *)jarg1;
40822   argp2 = (Dali::Radian *)jarg2;
40823   if (!argp2) {
40824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40825     return ;
40826   }
40827   arg2 = *argp2;
40828   argp3 = (Dali::Radian *)jarg3;
40829   if (!argp3) {
40830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40831     return ;
40832   }
40833   arg3 = *argp3;
40834   {
40835     try {
40836       (arg1)->AddDirection(arg2,arg3);
40837     } catch (std::out_of_range& e) {
40838       {
40839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40840       };
40841     } catch (std::exception& e) {
40842       {
40843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40844       };
40845     } catch (Dali::DaliException e) {
40846       {
40847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40848       };
40849     } catch (...) {
40850       {
40851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40852       };
40853     }
40854   }
40855
40856 }
40857
40858
40859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40860   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40861   Dali::Radian arg2 ;
40862   Dali::Radian *argp2 ;
40863
40864   arg1 = (Dali::PanGestureDetector *)jarg1;
40865   argp2 = (Dali::Radian *)jarg2;
40866   if (!argp2) {
40867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40868     return ;
40869   }
40870   arg2 = *argp2;
40871   {
40872     try {
40873       (arg1)->AddDirection(arg2);
40874     } catch (std::out_of_range& e) {
40875       {
40876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40877       };
40878     } catch (std::exception& e) {
40879       {
40880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40881       };
40882     } catch (Dali::DaliException e) {
40883       {
40884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40885       };
40886     } catch (...) {
40887       {
40888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40889       };
40890     }
40891   }
40892
40893 }
40894
40895
40896 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40897   unsigned long jresult ;
40898   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40899   size_t result;
40900
40901   arg1 = (Dali::PanGestureDetector *)jarg1;
40902   {
40903     try {
40904       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40905     } catch (std::out_of_range& e) {
40906       {
40907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40908       };
40909     } catch (std::exception& e) {
40910       {
40911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40912       };
40913     } catch (Dali::DaliException e) {
40914       {
40915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40916       };
40917     } catch (...) {
40918       {
40919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40920       };
40921     }
40922   }
40923
40924   jresult = (unsigned long)result;
40925   return jresult;
40926 }
40927
40928
40929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40930   void * jresult ;
40931   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40932   size_t arg2 ;
40933   Dali::PanGestureDetector::AngleThresholdPair result;
40934
40935   arg1 = (Dali::PanGestureDetector *)jarg1;
40936   arg2 = (size_t)jarg2;
40937   {
40938     try {
40939       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40940     } catch (std::out_of_range& e) {
40941       {
40942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40943       };
40944     } catch (std::exception& e) {
40945       {
40946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40947       };
40948     } catch (Dali::DaliException e) {
40949       {
40950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40951       };
40952     } catch (...) {
40953       {
40954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40955       };
40956     }
40957   }
40958
40959   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40960   return jresult;
40961 }
40962
40963
40964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40965   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40966
40967   arg1 = (Dali::PanGestureDetector *)jarg1;
40968   {
40969     try {
40970       (arg1)->ClearAngles();
40971     } catch (std::out_of_range& e) {
40972       {
40973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40974       };
40975     } catch (std::exception& e) {
40976       {
40977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40978       };
40979     } catch (Dali::DaliException e) {
40980       {
40981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40982       };
40983     } catch (...) {
40984       {
40985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40986       };
40987     }
40988   }
40989
40990 }
40991
40992
40993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40994   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40995   Dali::Radian arg2 ;
40996   Dali::Radian *argp2 ;
40997
40998   arg1 = (Dali::PanGestureDetector *)jarg1;
40999   argp2 = (Dali::Radian *)jarg2;
41000   if (!argp2) {
41001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41002     return ;
41003   }
41004   arg2 = *argp2;
41005   {
41006     try {
41007       (arg1)->RemoveAngle(arg2);
41008     } catch (std::out_of_range& e) {
41009       {
41010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41011       };
41012     } catch (std::exception& e) {
41013       {
41014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41015       };
41016     } catch (Dali::DaliException e) {
41017       {
41018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41019       };
41020     } catch (...) {
41021       {
41022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41023       };
41024     }
41025   }
41026
41027 }
41028
41029
41030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41031   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41032   Dali::Radian arg2 ;
41033   Dali::Radian *argp2 ;
41034
41035   arg1 = (Dali::PanGestureDetector *)jarg1;
41036   argp2 = (Dali::Radian *)jarg2;
41037   if (!argp2) {
41038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41039     return ;
41040   }
41041   arg2 = *argp2;
41042   {
41043     try {
41044       (arg1)->RemoveDirection(arg2);
41045     } catch (std::out_of_range& e) {
41046       {
41047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41048       };
41049     } catch (std::exception& e) {
41050       {
41051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41052       };
41053     } catch (Dali::DaliException e) {
41054       {
41055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41056       };
41057     } catch (...) {
41058       {
41059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41060       };
41061     }
41062   }
41063
41064 }
41065
41066
41067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41068   void * jresult ;
41069   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41070   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41071
41072   arg1 = (Dali::PanGestureDetector *)jarg1;
41073   {
41074     try {
41075       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41076     } catch (std::out_of_range& e) {
41077       {
41078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41079       };
41080     } catch (std::exception& e) {
41081       {
41082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41083       };
41084     } catch (Dali::DaliException e) {
41085       {
41086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41087       };
41088     } catch (...) {
41089       {
41090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41091       };
41092     }
41093   }
41094
41095   jresult = (void *)result;
41096   return jresult;
41097 }
41098
41099
41100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41101   Dali::PanGesture *arg1 = 0 ;
41102
41103   arg1 = (Dali::PanGesture *)jarg1;
41104   if (!arg1) {
41105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41106     return ;
41107   }
41108   {
41109     try {
41110       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41111     } catch (std::out_of_range& e) {
41112       {
41113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41114       };
41115     } catch (std::exception& e) {
41116       {
41117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41118       };
41119     } catch (Dali::DaliException e) {
41120       {
41121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41122       };
41123     } catch (...) {
41124       {
41125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41126       };
41127     }
41128   }
41129
41130 }
41131
41132
41133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41134   void * jresult ;
41135   Dali::PanGesture *result = 0 ;
41136
41137   {
41138     try {
41139       result = (Dali::PanGesture *)new Dali::PanGesture();
41140     } catch (std::out_of_range& e) {
41141       {
41142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41143       };
41144     } catch (std::exception& e) {
41145       {
41146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41147       };
41148     } catch (Dali::DaliException e) {
41149       {
41150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41151       };
41152     } catch (...) {
41153       {
41154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41155       };
41156     }
41157   }
41158
41159   jresult = (void *)result;
41160   return jresult;
41161 }
41162
41163
41164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41165   void * jresult ;
41166   Dali::Gesture::State arg1 ;
41167   Dali::PanGesture *result = 0 ;
41168
41169   arg1 = (Dali::Gesture::State)jarg1;
41170   {
41171     try {
41172       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41173     } catch (std::out_of_range& e) {
41174       {
41175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41176       };
41177     } catch (std::exception& e) {
41178       {
41179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41180       };
41181     } catch (Dali::DaliException e) {
41182       {
41183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41184       };
41185     } catch (...) {
41186       {
41187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41188       };
41189     }
41190   }
41191
41192   jresult = (void *)result;
41193   return jresult;
41194 }
41195
41196
41197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41198   void * jresult ;
41199   Dali::PanGesture *arg1 = 0 ;
41200   Dali::PanGesture *result = 0 ;
41201
41202   arg1 = (Dali::PanGesture *)jarg1;
41203   if (!arg1) {
41204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41205     return 0;
41206   }
41207   {
41208     try {
41209       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41210     } catch (std::out_of_range& e) {
41211       {
41212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41213       };
41214     } catch (std::exception& e) {
41215       {
41216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41217       };
41218     } catch (Dali::DaliException e) {
41219       {
41220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41221       };
41222     } catch (...) {
41223       {
41224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41225       };
41226     }
41227   }
41228
41229   jresult = (void *)result;
41230   return jresult;
41231 }
41232
41233
41234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41235   void * jresult ;
41236   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41237   Dali::PanGesture *arg2 = 0 ;
41238   Dali::PanGesture *result = 0 ;
41239
41240   arg1 = (Dali::PanGesture *)jarg1;
41241   arg2 = (Dali::PanGesture *)jarg2;
41242   if (!arg2) {
41243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41244     return 0;
41245   }
41246   {
41247     try {
41248       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41249     } catch (std::out_of_range& e) {
41250       {
41251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41252       };
41253     } catch (std::exception& e) {
41254       {
41255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41256       };
41257     } catch (Dali::DaliException e) {
41258       {
41259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41260       };
41261     } catch (...) {
41262       {
41263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41264       };
41265     }
41266   }
41267
41268   jresult = (void *)result;
41269   return jresult;
41270 }
41271
41272
41273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41274   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41275
41276   arg1 = (Dali::PanGesture *)jarg1;
41277   {
41278     try {
41279       delete arg1;
41280     } catch (std::out_of_range& e) {
41281       {
41282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41283       };
41284     } catch (std::exception& e) {
41285       {
41286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41287       };
41288     } catch (Dali::DaliException e) {
41289       {
41290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41291       };
41292     } catch (...) {
41293       {
41294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41295       };
41296     }
41297   }
41298
41299 }
41300
41301
41302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41303   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41304   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41305
41306   arg1 = (Dali::PanGesture *)jarg1;
41307   arg2 = (Dali::Vector2 *)jarg2;
41308   if (arg1) (arg1)->velocity = *arg2;
41309 }
41310
41311
41312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41313   void * jresult ;
41314   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41315   Dali::Vector2 *result = 0 ;
41316
41317   arg1 = (Dali::PanGesture *)jarg1;
41318   result = (Dali::Vector2 *)& ((arg1)->velocity);
41319   jresult = (void *)result;
41320   return jresult;
41321 }
41322
41323
41324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41325   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41326   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41327
41328   arg1 = (Dali::PanGesture *)jarg1;
41329   arg2 = (Dali::Vector2 *)jarg2;
41330   if (arg1) (arg1)->displacement = *arg2;
41331 }
41332
41333
41334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41335   void * jresult ;
41336   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41337   Dali::Vector2 *result = 0 ;
41338
41339   arg1 = (Dali::PanGesture *)jarg1;
41340   result = (Dali::Vector2 *)& ((arg1)->displacement);
41341   jresult = (void *)result;
41342   return jresult;
41343 }
41344
41345
41346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41347   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41348   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41349
41350   arg1 = (Dali::PanGesture *)jarg1;
41351   arg2 = (Dali::Vector2 *)jarg2;
41352   if (arg1) (arg1)->position = *arg2;
41353 }
41354
41355
41356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41357   void * jresult ;
41358   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41359   Dali::Vector2 *result = 0 ;
41360
41361   arg1 = (Dali::PanGesture *)jarg1;
41362   result = (Dali::Vector2 *)& ((arg1)->position);
41363   jresult = (void *)result;
41364   return jresult;
41365 }
41366
41367
41368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41369   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41370   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41371
41372   arg1 = (Dali::PanGesture *)jarg1;
41373   arg2 = (Dali::Vector2 *)jarg2;
41374   if (arg1) (arg1)->screenVelocity = *arg2;
41375 }
41376
41377
41378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41379   void * jresult ;
41380   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41381   Dali::Vector2 *result = 0 ;
41382
41383   arg1 = (Dali::PanGesture *)jarg1;
41384   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41385   jresult = (void *)result;
41386   return jresult;
41387 }
41388
41389
41390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41391   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41392   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41393
41394   arg1 = (Dali::PanGesture *)jarg1;
41395   arg2 = (Dali::Vector2 *)jarg2;
41396   if (arg1) (arg1)->screenDisplacement = *arg2;
41397 }
41398
41399
41400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41401   void * jresult ;
41402   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41403   Dali::Vector2 *result = 0 ;
41404
41405   arg1 = (Dali::PanGesture *)jarg1;
41406   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41407   jresult = (void *)result;
41408   return jresult;
41409 }
41410
41411
41412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41413   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41414   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41415
41416   arg1 = (Dali::PanGesture *)jarg1;
41417   arg2 = (Dali::Vector2 *)jarg2;
41418   if (arg1) (arg1)->screenPosition = *arg2;
41419 }
41420
41421
41422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41423   void * jresult ;
41424   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41425   Dali::Vector2 *result = 0 ;
41426
41427   arg1 = (Dali::PanGesture *)jarg1;
41428   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41429   jresult = (void *)result;
41430   return jresult;
41431 }
41432
41433
41434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41435   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41436   unsigned int arg2 ;
41437
41438   arg1 = (Dali::PanGesture *)jarg1;
41439   arg2 = (unsigned int)jarg2;
41440   if (arg1) (arg1)->numberOfTouches = arg2;
41441 }
41442
41443
41444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41445   unsigned int jresult ;
41446   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41447   unsigned int result;
41448
41449   arg1 = (Dali::PanGesture *)jarg1;
41450   result = (unsigned int) ((arg1)->numberOfTouches);
41451   jresult = result;
41452   return jresult;
41453 }
41454
41455
41456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41457   float jresult ;
41458   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41459   float result;
41460
41461   arg1 = (Dali::PanGesture *)jarg1;
41462   {
41463     try {
41464       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41465     } catch (std::out_of_range& e) {
41466       {
41467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41468       };
41469     } catch (std::exception& e) {
41470       {
41471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41472       };
41473     } catch (Dali::DaliException e) {
41474       {
41475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41476       };
41477     } catch (...) {
41478       {
41479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41480       };
41481     }
41482   }
41483
41484   jresult = result;
41485   return jresult;
41486 }
41487
41488
41489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41490   float jresult ;
41491   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41492   float result;
41493
41494   arg1 = (Dali::PanGesture *)jarg1;
41495   {
41496     try {
41497       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41498     } catch (std::out_of_range& e) {
41499       {
41500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41501       };
41502     } catch (std::exception& e) {
41503       {
41504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41505       };
41506     } catch (Dali::DaliException e) {
41507       {
41508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41509       };
41510     } catch (...) {
41511       {
41512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41513       };
41514     }
41515   }
41516
41517   jresult = result;
41518   return jresult;
41519 }
41520
41521
41522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41523   float jresult ;
41524   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41525   float result;
41526
41527   arg1 = (Dali::PanGesture *)jarg1;
41528   {
41529     try {
41530       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41531     } catch (std::out_of_range& e) {
41532       {
41533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41534       };
41535     } catch (std::exception& e) {
41536       {
41537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41538       };
41539     } catch (Dali::DaliException e) {
41540       {
41541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41542       };
41543     } catch (...) {
41544       {
41545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41546       };
41547     }
41548   }
41549
41550   jresult = result;
41551   return jresult;
41552 }
41553
41554
41555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41556   float jresult ;
41557   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41558   float result;
41559
41560   arg1 = (Dali::PanGesture *)jarg1;
41561   {
41562     try {
41563       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41564     } catch (std::out_of_range& e) {
41565       {
41566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41567       };
41568     } catch (std::exception& e) {
41569       {
41570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41571       };
41572     } catch (Dali::DaliException e) {
41573       {
41574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41575       };
41576     } catch (...) {
41577       {
41578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41579       };
41580     }
41581   }
41582
41583   jresult = result;
41584   return jresult;
41585 }
41586
41587
41588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41589   void * jresult ;
41590   Dali::PinchGestureDetector *result = 0 ;
41591
41592   {
41593     try {
41594       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41595     } catch (std::out_of_range& e) {
41596       {
41597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41598       };
41599     } catch (std::exception& e) {
41600       {
41601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41602       };
41603     } catch (Dali::DaliException e) {
41604       {
41605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41606       };
41607     } catch (...) {
41608       {
41609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41610       };
41611     }
41612   }
41613
41614   jresult = (void *)result;
41615   return jresult;
41616 }
41617
41618
41619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41620   void * jresult ;
41621   Dali::PinchGestureDetector result;
41622
41623   {
41624     try {
41625       result = Dali::PinchGestureDetector::New();
41626     } catch (std::out_of_range& e) {
41627       {
41628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41629       };
41630     } catch (std::exception& e) {
41631       {
41632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41633       };
41634     } catch (Dali::DaliException e) {
41635       {
41636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41637       };
41638     } catch (...) {
41639       {
41640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41641       };
41642     }
41643   }
41644
41645   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41646   return jresult;
41647 }
41648
41649
41650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41651   void * jresult ;
41652   Dali::BaseHandle arg1 ;
41653   Dali::BaseHandle *argp1 ;
41654   Dali::PinchGestureDetector result;
41655
41656   argp1 = (Dali::BaseHandle *)jarg1;
41657   if (!argp1) {
41658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41659     return 0;
41660   }
41661   arg1 = *argp1;
41662   {
41663     try {
41664       result = Dali::PinchGestureDetector::DownCast(arg1);
41665     } catch (std::out_of_range& e) {
41666       {
41667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41668       };
41669     } catch (std::exception& e) {
41670       {
41671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41672       };
41673     } catch (Dali::DaliException e) {
41674       {
41675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41676       };
41677     } catch (...) {
41678       {
41679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41680       };
41681     }
41682   }
41683
41684   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41685   return jresult;
41686 }
41687
41688
41689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41690   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41691
41692   arg1 = (Dali::PinchGestureDetector *)jarg1;
41693   {
41694     try {
41695       delete arg1;
41696     } catch (std::out_of_range& e) {
41697       {
41698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41699       };
41700     } catch (std::exception& e) {
41701       {
41702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41703       };
41704     } catch (Dali::DaliException e) {
41705       {
41706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41707       };
41708     } catch (...) {
41709       {
41710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41711       };
41712     }
41713   }
41714
41715 }
41716
41717
41718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41719   void * jresult ;
41720   Dali::PinchGestureDetector *arg1 = 0 ;
41721   Dali::PinchGestureDetector *result = 0 ;
41722
41723   arg1 = (Dali::PinchGestureDetector *)jarg1;
41724   if (!arg1) {
41725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41726     return 0;
41727   }
41728   {
41729     try {
41730       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41731     } catch (std::out_of_range& e) {
41732       {
41733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41734       };
41735     } catch (std::exception& e) {
41736       {
41737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41738       };
41739     } catch (Dali::DaliException e) {
41740       {
41741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41742       };
41743     } catch (...) {
41744       {
41745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41746       };
41747     }
41748   }
41749
41750   jresult = (void *)result;
41751   return jresult;
41752 }
41753
41754
41755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41756   void * jresult ;
41757   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41758   Dali::PinchGestureDetector *arg2 = 0 ;
41759   Dali::PinchGestureDetector *result = 0 ;
41760
41761   arg1 = (Dali::PinchGestureDetector *)jarg1;
41762   arg2 = (Dali::PinchGestureDetector *)jarg2;
41763   if (!arg2) {
41764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41765     return 0;
41766   }
41767   {
41768     try {
41769       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41770     } catch (std::out_of_range& e) {
41771       {
41772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41773       };
41774     } catch (std::exception& e) {
41775       {
41776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41777       };
41778     } catch (Dali::DaliException e) {
41779       {
41780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41781       };
41782     } catch (...) {
41783       {
41784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41785       };
41786     }
41787   }
41788
41789   jresult = (void *)result;
41790   return jresult;
41791 }
41792
41793
41794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41795   void * jresult ;
41796   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41797   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41798
41799   arg1 = (Dali::PinchGestureDetector *)jarg1;
41800   {
41801     try {
41802       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41803     } catch (std::out_of_range& e) {
41804       {
41805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41806       };
41807     } catch (std::exception& e) {
41808       {
41809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41810       };
41811     } catch (Dali::DaliException e) {
41812       {
41813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41814       };
41815     } catch (...) {
41816       {
41817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41818       };
41819     }
41820   }
41821
41822   jresult = (void *)result;
41823   return jresult;
41824 }
41825
41826
41827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41828   void * jresult ;
41829   Dali::Gesture::State arg1 ;
41830   Dali::PinchGesture *result = 0 ;
41831
41832   arg1 = (Dali::Gesture::State)jarg1;
41833   {
41834     try {
41835       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41836     } catch (std::out_of_range& e) {
41837       {
41838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41839       };
41840     } catch (std::exception& e) {
41841       {
41842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41843       };
41844     } catch (Dali::DaliException e) {
41845       {
41846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41847       };
41848     } catch (...) {
41849       {
41850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41851       };
41852     }
41853   }
41854
41855   jresult = (void *)result;
41856   return jresult;
41857 }
41858
41859
41860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41861   void * jresult ;
41862   Dali::PinchGesture *arg1 = 0 ;
41863   Dali::PinchGesture *result = 0 ;
41864
41865   arg1 = (Dali::PinchGesture *)jarg1;
41866   if (!arg1) {
41867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41868     return 0;
41869   }
41870   {
41871     try {
41872       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41873     } catch (std::out_of_range& e) {
41874       {
41875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41876       };
41877     } catch (std::exception& e) {
41878       {
41879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41880       };
41881     } catch (Dali::DaliException e) {
41882       {
41883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41884       };
41885     } catch (...) {
41886       {
41887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41888       };
41889     }
41890   }
41891
41892   jresult = (void *)result;
41893   return jresult;
41894 }
41895
41896
41897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41898   void * jresult ;
41899   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41900   Dali::PinchGesture *arg2 = 0 ;
41901   Dali::PinchGesture *result = 0 ;
41902
41903   arg1 = (Dali::PinchGesture *)jarg1;
41904   arg2 = (Dali::PinchGesture *)jarg2;
41905   if (!arg2) {
41906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41907     return 0;
41908   }
41909   {
41910     try {
41911       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41912     } catch (std::out_of_range& e) {
41913       {
41914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41915       };
41916     } catch (std::exception& e) {
41917       {
41918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41919       };
41920     } catch (Dali::DaliException e) {
41921       {
41922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41923       };
41924     } catch (...) {
41925       {
41926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41927       };
41928     }
41929   }
41930
41931   jresult = (void *)result;
41932   return jresult;
41933 }
41934
41935
41936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41937   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41938
41939   arg1 = (Dali::PinchGesture *)jarg1;
41940   {
41941     try {
41942       delete arg1;
41943     } catch (std::out_of_range& e) {
41944       {
41945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41946       };
41947     } catch (std::exception& e) {
41948       {
41949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41950       };
41951     } catch (Dali::DaliException e) {
41952       {
41953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41954       };
41955     } catch (...) {
41956       {
41957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41958       };
41959     }
41960   }
41961
41962 }
41963
41964
41965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41966   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41967   float arg2 ;
41968
41969   arg1 = (Dali::PinchGesture *)jarg1;
41970   arg2 = (float)jarg2;
41971   if (arg1) (arg1)->scale = arg2;
41972 }
41973
41974
41975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41976   float jresult ;
41977   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41978   float result;
41979
41980   arg1 = (Dali::PinchGesture *)jarg1;
41981   result = (float) ((arg1)->scale);
41982   jresult = result;
41983   return jresult;
41984 }
41985
41986
41987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41988   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41989   float arg2 ;
41990
41991   arg1 = (Dali::PinchGesture *)jarg1;
41992   arg2 = (float)jarg2;
41993   if (arg1) (arg1)->speed = arg2;
41994 }
41995
41996
41997 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41998   float jresult ;
41999   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42000   float result;
42001
42002   arg1 = (Dali::PinchGesture *)jarg1;
42003   result = (float) ((arg1)->speed);
42004   jresult = result;
42005   return jresult;
42006 }
42007
42008
42009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42010   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42011   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42012
42013   arg1 = (Dali::PinchGesture *)jarg1;
42014   arg2 = (Dali::Vector2 *)jarg2;
42015   if (arg1) (arg1)->screenCenterPoint = *arg2;
42016 }
42017
42018
42019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42020   void * jresult ;
42021   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42022   Dali::Vector2 *result = 0 ;
42023
42024   arg1 = (Dali::PinchGesture *)jarg1;
42025   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42026   jresult = (void *)result;
42027   return jresult;
42028 }
42029
42030
42031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42032   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42033   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42034
42035   arg1 = (Dali::PinchGesture *)jarg1;
42036   arg2 = (Dali::Vector2 *)jarg2;
42037   if (arg1) (arg1)->localCenterPoint = *arg2;
42038 }
42039
42040
42041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42042   void * jresult ;
42043   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42044   Dali::Vector2 *result = 0 ;
42045
42046   arg1 = (Dali::PinchGesture *)jarg1;
42047   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42048   jresult = (void *)result;
42049   return jresult;
42050 }
42051
42052
42053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42054   void * jresult ;
42055   Dali::TapGestureDetector *result = 0 ;
42056
42057   {
42058     try {
42059       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42060     } catch (std::out_of_range& e) {
42061       {
42062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42063       };
42064     } catch (std::exception& e) {
42065       {
42066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42067       };
42068     } catch (Dali::DaliException e) {
42069       {
42070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42071       };
42072     } catch (...) {
42073       {
42074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42075       };
42076     }
42077   }
42078
42079   jresult = (void *)result;
42080   return jresult;
42081 }
42082
42083
42084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42085   void * jresult ;
42086   Dali::TapGestureDetector result;
42087
42088   {
42089     try {
42090       result = Dali::TapGestureDetector::New();
42091     } catch (std::out_of_range& e) {
42092       {
42093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42094       };
42095     } catch (std::exception& e) {
42096       {
42097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42098       };
42099     } catch (Dali::DaliException e) {
42100       {
42101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42102       };
42103     } catch (...) {
42104       {
42105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42106       };
42107     }
42108   }
42109
42110   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42111   return jresult;
42112 }
42113
42114
42115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42116   void * jresult ;
42117   unsigned int arg1 ;
42118   Dali::TapGestureDetector result;
42119
42120   arg1 = (unsigned int)jarg1;
42121   {
42122     try {
42123       result = Dali::TapGestureDetector::New(arg1);
42124     } catch (std::out_of_range& e) {
42125       {
42126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42127       };
42128     } catch (std::exception& e) {
42129       {
42130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42131       };
42132     } catch (Dali::DaliException e) {
42133       {
42134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42135       };
42136     } catch (...) {
42137       {
42138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42139       };
42140     }
42141   }
42142
42143   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42144   return jresult;
42145 }
42146
42147
42148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42149   void * jresult ;
42150   Dali::BaseHandle arg1 ;
42151   Dali::BaseHandle *argp1 ;
42152   Dali::TapGestureDetector result;
42153
42154   argp1 = (Dali::BaseHandle *)jarg1;
42155   if (!argp1) {
42156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42157     return 0;
42158   }
42159   arg1 = *argp1;
42160   {
42161     try {
42162       result = Dali::TapGestureDetector::DownCast(arg1);
42163     } catch (std::out_of_range& e) {
42164       {
42165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42166       };
42167     } catch (std::exception& e) {
42168       {
42169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42170       };
42171     } catch (Dali::DaliException e) {
42172       {
42173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42174       };
42175     } catch (...) {
42176       {
42177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42178       };
42179     }
42180   }
42181
42182   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42183   return jresult;
42184 }
42185
42186
42187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42188   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42189
42190   arg1 = (Dali::TapGestureDetector *)jarg1;
42191   {
42192     try {
42193       delete arg1;
42194     } catch (std::out_of_range& e) {
42195       {
42196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42197       };
42198     } catch (std::exception& e) {
42199       {
42200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42201       };
42202     } catch (Dali::DaliException e) {
42203       {
42204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42205       };
42206     } catch (...) {
42207       {
42208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42209       };
42210     }
42211   }
42212
42213 }
42214
42215
42216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42217   void * jresult ;
42218   Dali::TapGestureDetector *arg1 = 0 ;
42219   Dali::TapGestureDetector *result = 0 ;
42220
42221   arg1 = (Dali::TapGestureDetector *)jarg1;
42222   if (!arg1) {
42223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42224     return 0;
42225   }
42226   {
42227     try {
42228       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42229     } catch (std::out_of_range& e) {
42230       {
42231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42232       };
42233     } catch (std::exception& e) {
42234       {
42235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42236       };
42237     } catch (Dali::DaliException e) {
42238       {
42239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42240       };
42241     } catch (...) {
42242       {
42243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42244       };
42245     }
42246   }
42247
42248   jresult = (void *)result;
42249   return jresult;
42250 }
42251
42252
42253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42254   void * jresult ;
42255   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42256   Dali::TapGestureDetector *arg2 = 0 ;
42257   Dali::TapGestureDetector *result = 0 ;
42258
42259   arg1 = (Dali::TapGestureDetector *)jarg1;
42260   arg2 = (Dali::TapGestureDetector *)jarg2;
42261   if (!arg2) {
42262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42263     return 0;
42264   }
42265   {
42266     try {
42267       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42268     } catch (std::out_of_range& e) {
42269       {
42270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42271       };
42272     } catch (std::exception& e) {
42273       {
42274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42275       };
42276     } catch (Dali::DaliException e) {
42277       {
42278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42279       };
42280     } catch (...) {
42281       {
42282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42283       };
42284     }
42285   }
42286
42287   jresult = (void *)result;
42288   return jresult;
42289 }
42290
42291
42292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42293   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42294   unsigned int arg2 ;
42295
42296   arg1 = (Dali::TapGestureDetector *)jarg1;
42297   arg2 = (unsigned int)jarg2;
42298   {
42299     try {
42300       (arg1)->SetMinimumTapsRequired(arg2);
42301     } catch (std::out_of_range& e) {
42302       {
42303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42304       };
42305     } catch (std::exception& e) {
42306       {
42307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42308       };
42309     } catch (Dali::DaliException e) {
42310       {
42311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42312       };
42313     } catch (...) {
42314       {
42315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42316       };
42317     }
42318   }
42319
42320 }
42321
42322
42323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42324   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42325   unsigned int arg2 ;
42326
42327   arg1 = (Dali::TapGestureDetector *)jarg1;
42328   arg2 = (unsigned int)jarg2;
42329   {
42330     try {
42331       (arg1)->SetMaximumTapsRequired(arg2);
42332     } catch (std::out_of_range& e) {
42333       {
42334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42335       };
42336     } catch (std::exception& e) {
42337       {
42338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42339       };
42340     } catch (Dali::DaliException e) {
42341       {
42342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42343       };
42344     } catch (...) {
42345       {
42346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42347       };
42348     }
42349   }
42350
42351 }
42352
42353
42354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42355   unsigned int jresult ;
42356   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42357   unsigned int result;
42358
42359   arg1 = (Dali::TapGestureDetector *)jarg1;
42360   {
42361     try {
42362       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42363     } catch (std::out_of_range& e) {
42364       {
42365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42366       };
42367     } catch (std::exception& e) {
42368       {
42369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42370       };
42371     } catch (Dali::DaliException e) {
42372       {
42373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42374       };
42375     } catch (...) {
42376       {
42377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42378       };
42379     }
42380   }
42381
42382   jresult = result;
42383   return jresult;
42384 }
42385
42386
42387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42388   unsigned int jresult ;
42389   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42390   unsigned int result;
42391
42392   arg1 = (Dali::TapGestureDetector *)jarg1;
42393   {
42394     try {
42395       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42396     } catch (std::out_of_range& e) {
42397       {
42398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42399       };
42400     } catch (std::exception& e) {
42401       {
42402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42403       };
42404     } catch (Dali::DaliException e) {
42405       {
42406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42407       };
42408     } catch (...) {
42409       {
42410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42411       };
42412     }
42413   }
42414
42415   jresult = result;
42416   return jresult;
42417 }
42418
42419
42420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42421   void * jresult ;
42422   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42423   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42424
42425   arg1 = (Dali::TapGestureDetector *)jarg1;
42426   {
42427     try {
42428       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42429     } catch (std::out_of_range& e) {
42430       {
42431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42432       };
42433     } catch (std::exception& e) {
42434       {
42435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42436       };
42437     } catch (Dali::DaliException e) {
42438       {
42439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42440       };
42441     } catch (...) {
42442       {
42443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42444       };
42445     }
42446   }
42447
42448   jresult = (void *)result;
42449   return jresult;
42450 }
42451
42452
42453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42454   void * jresult ;
42455   Dali::TapGesture *result = 0 ;
42456
42457   {
42458     try {
42459       result = (Dali::TapGesture *)new Dali::TapGesture();
42460     } catch (std::out_of_range& e) {
42461       {
42462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42463       };
42464     } catch (std::exception& e) {
42465       {
42466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42467       };
42468     } catch (Dali::DaliException e) {
42469       {
42470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42471       };
42472     } catch (...) {
42473       {
42474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42475       };
42476     }
42477   }
42478
42479   jresult = (void *)result;
42480   return jresult;
42481 }
42482
42483
42484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42485   void * jresult ;
42486   Dali::TapGesture *arg1 = 0 ;
42487   Dali::TapGesture *result = 0 ;
42488
42489   arg1 = (Dali::TapGesture *)jarg1;
42490   if (!arg1) {
42491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42492     return 0;
42493   }
42494   {
42495     try {
42496       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42497     } catch (std::out_of_range& e) {
42498       {
42499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42500       };
42501     } catch (std::exception& e) {
42502       {
42503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42504       };
42505     } catch (Dali::DaliException e) {
42506       {
42507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42508       };
42509     } catch (...) {
42510       {
42511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42512       };
42513     }
42514   }
42515
42516   jresult = (void *)result;
42517   return jresult;
42518 }
42519
42520
42521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42522   void * jresult ;
42523   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42524   Dali::TapGesture *arg2 = 0 ;
42525   Dali::TapGesture *result = 0 ;
42526
42527   arg1 = (Dali::TapGesture *)jarg1;
42528   arg2 = (Dali::TapGesture *)jarg2;
42529   if (!arg2) {
42530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42531     return 0;
42532   }
42533   {
42534     try {
42535       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42536     } catch (std::out_of_range& e) {
42537       {
42538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42539       };
42540     } catch (std::exception& e) {
42541       {
42542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42543       };
42544     } catch (Dali::DaliException e) {
42545       {
42546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42547       };
42548     } catch (...) {
42549       {
42550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42551       };
42552     }
42553   }
42554
42555   jresult = (void *)result;
42556   return jresult;
42557 }
42558
42559
42560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42561   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42562
42563   arg1 = (Dali::TapGesture *)jarg1;
42564   {
42565     try {
42566       delete arg1;
42567     } catch (std::out_of_range& e) {
42568       {
42569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42570       };
42571     } catch (std::exception& e) {
42572       {
42573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42574       };
42575     } catch (Dali::DaliException e) {
42576       {
42577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42578       };
42579     } catch (...) {
42580       {
42581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42582       };
42583     }
42584   }
42585
42586 }
42587
42588
42589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42590   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42591   unsigned int arg2 ;
42592
42593   arg1 = (Dali::TapGesture *)jarg1;
42594   arg2 = (unsigned int)jarg2;
42595   if (arg1) (arg1)->numberOfTaps = arg2;
42596 }
42597
42598
42599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42600   unsigned int jresult ;
42601   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42602   unsigned int result;
42603
42604   arg1 = (Dali::TapGesture *)jarg1;
42605   result = (unsigned int) ((arg1)->numberOfTaps);
42606   jresult = result;
42607   return jresult;
42608 }
42609
42610
42611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42612   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42613   unsigned int arg2 ;
42614
42615   arg1 = (Dali::TapGesture *)jarg1;
42616   arg2 = (unsigned int)jarg2;
42617   if (arg1) (arg1)->numberOfTouches = arg2;
42618 }
42619
42620
42621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42622   unsigned int jresult ;
42623   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42624   unsigned int result;
42625
42626   arg1 = (Dali::TapGesture *)jarg1;
42627   result = (unsigned int) ((arg1)->numberOfTouches);
42628   jresult = result;
42629   return jresult;
42630 }
42631
42632
42633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42634   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42635   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42636
42637   arg1 = (Dali::TapGesture *)jarg1;
42638   arg2 = (Dali::Vector2 *)jarg2;
42639   if (arg1) (arg1)->screenPoint = *arg2;
42640 }
42641
42642
42643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42644   void * jresult ;
42645   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42646   Dali::Vector2 *result = 0 ;
42647
42648   arg1 = (Dali::TapGesture *)jarg1;
42649   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42650   jresult = (void *)result;
42651   return jresult;
42652 }
42653
42654
42655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42656   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42657   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42658
42659   arg1 = (Dali::TapGesture *)jarg1;
42660   arg2 = (Dali::Vector2 *)jarg2;
42661   if (arg1) (arg1)->localPoint = *arg2;
42662 }
42663
42664
42665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42666   void * jresult ;
42667   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42668   Dali::Vector2 *result = 0 ;
42669
42670   arg1 = (Dali::TapGesture *)jarg1;
42671   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42672   jresult = (void *)result;
42673   return jresult;
42674 }
42675
42676
42677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42678   void * jresult ;
42679   Dali::AlphaFunction *result = 0 ;
42680
42681   {
42682     try {
42683       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42684     } catch (std::out_of_range& e) {
42685       {
42686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42687       };
42688     } catch (std::exception& e) {
42689       {
42690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42691       };
42692     } catch (Dali::DaliException e) {
42693       {
42694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42695       };
42696     } catch (...) {
42697       {
42698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42699       };
42700     }
42701   }
42702
42703   jresult = (void *)result;
42704   return jresult;
42705 }
42706
42707
42708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42709   void * jresult ;
42710   Dali::AlphaFunction::BuiltinFunction arg1 ;
42711   Dali::AlphaFunction *result = 0 ;
42712
42713   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42714   {
42715     try {
42716       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42717     } catch (std::out_of_range& e) {
42718       {
42719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42720       };
42721     } catch (std::exception& e) {
42722       {
42723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42724       };
42725     } catch (Dali::DaliException e) {
42726       {
42727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42728       };
42729     } catch (...) {
42730       {
42731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42732       };
42733     }
42734   }
42735
42736   jresult = (void *)result;
42737   return jresult;
42738 }
42739
42740
42741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42742   void * jresult ;
42743   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42744   Dali::AlphaFunction *result = 0 ;
42745
42746   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42747   {
42748     try {
42749       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42750     } catch (std::out_of_range& e) {
42751       {
42752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42753       };
42754     } catch (std::exception& e) {
42755       {
42756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42757       };
42758     } catch (Dali::DaliException e) {
42759       {
42760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42761       };
42762     } catch (...) {
42763       {
42764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42765       };
42766     }
42767   }
42768
42769   jresult = (void *)result;
42770   return jresult;
42771 }
42772
42773
42774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42775   void * jresult ;
42776   Dali::Vector2 *arg1 = 0 ;
42777   Dali::Vector2 *arg2 = 0 ;
42778   Dali::AlphaFunction *result = 0 ;
42779
42780   arg1 = (Dali::Vector2 *)jarg1;
42781   if (!arg1) {
42782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42783     return 0;
42784   }
42785   arg2 = (Dali::Vector2 *)jarg2;
42786   if (!arg2) {
42787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42788     return 0;
42789   }
42790   {
42791     try {
42792       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42793     } catch (std::out_of_range& e) {
42794       {
42795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42796       };
42797     } catch (std::exception& e) {
42798       {
42799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42800       };
42801     } catch (Dali::DaliException e) {
42802       {
42803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42804       };
42805     } catch (...) {
42806       {
42807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42808       };
42809     }
42810   }
42811
42812   jresult = (void *)result;
42813   return jresult;
42814 }
42815
42816
42817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42818   void * jresult ;
42819   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42820   Dali::Vector4 result;
42821
42822   arg1 = (Dali::AlphaFunction *)jarg1;
42823   {
42824     try {
42825       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42826     } catch (std::out_of_range& e) {
42827       {
42828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42829       };
42830     } catch (std::exception& e) {
42831       {
42832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42833       };
42834     } catch (Dali::DaliException e) {
42835       {
42836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42837       };
42838     } catch (...) {
42839       {
42840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42841       };
42842     }
42843   }
42844
42845   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42846   return jresult;
42847 }
42848
42849
42850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42851   void * jresult ;
42852   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42853   Dali::AlphaFunctionPrototype result;
42854
42855   arg1 = (Dali::AlphaFunction *)jarg1;
42856   {
42857     try {
42858       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42859     } catch (std::out_of_range& e) {
42860       {
42861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42862       };
42863     } catch (std::exception& e) {
42864       {
42865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42866       };
42867     } catch (Dali::DaliException e) {
42868       {
42869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42870       };
42871     } catch (...) {
42872       {
42873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42874       };
42875     }
42876   }
42877
42878   jresult = (void *)result;
42879   return jresult;
42880 }
42881
42882
42883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42884   int jresult ;
42885   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42886   Dali::AlphaFunction::BuiltinFunction result;
42887
42888   arg1 = (Dali::AlphaFunction *)jarg1;
42889   {
42890     try {
42891       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42892     } catch (std::out_of_range& e) {
42893       {
42894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42895       };
42896     } catch (std::exception& e) {
42897       {
42898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42899       };
42900     } catch (Dali::DaliException e) {
42901       {
42902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42903       };
42904     } catch (...) {
42905       {
42906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42907       };
42908     }
42909   }
42910
42911   jresult = (int)result;
42912   return jresult;
42913 }
42914
42915
42916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42917   int jresult ;
42918   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42919   Dali::AlphaFunction::Mode result;
42920
42921   arg1 = (Dali::AlphaFunction *)jarg1;
42922   {
42923     try {
42924       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42925     } catch (std::out_of_range& e) {
42926       {
42927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42928       };
42929     } catch (std::exception& e) {
42930       {
42931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42932       };
42933     } catch (Dali::DaliException e) {
42934       {
42935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42936       };
42937     } catch (...) {
42938       {
42939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42940       };
42941     }
42942   }
42943
42944   jresult = (int)result;
42945   return jresult;
42946 }
42947
42948
42949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42950   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42951
42952   arg1 = (Dali::AlphaFunction *)jarg1;
42953   {
42954     try {
42955       delete arg1;
42956     } catch (std::out_of_range& e) {
42957       {
42958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42959       };
42960     } catch (std::exception& e) {
42961       {
42962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42963       };
42964     } catch (Dali::DaliException e) {
42965       {
42966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42967       };
42968     } catch (...) {
42969       {
42970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42971       };
42972     }
42973   }
42974
42975 }
42976
42977
42978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42979   void * jresult ;
42980   Dali::KeyFrames result;
42981
42982   {
42983     try {
42984       result = Dali::KeyFrames::New();
42985     } catch (std::out_of_range& e) {
42986       {
42987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42988       };
42989     } catch (std::exception& e) {
42990       {
42991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42992       };
42993     } catch (Dali::DaliException e) {
42994       {
42995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42996       };
42997     } catch (...) {
42998       {
42999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43000       };
43001     }
43002   }
43003
43004   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43005   return jresult;
43006 }
43007
43008
43009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43010   void * jresult ;
43011   Dali::BaseHandle arg1 ;
43012   Dali::BaseHandle *argp1 ;
43013   Dali::KeyFrames result;
43014
43015   argp1 = (Dali::BaseHandle *)jarg1;
43016   if (!argp1) {
43017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43018     return 0;
43019   }
43020   arg1 = *argp1;
43021   {
43022     try {
43023       result = Dali::KeyFrames::DownCast(arg1);
43024     } catch (std::out_of_range& e) {
43025       {
43026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43027       };
43028     } catch (std::exception& e) {
43029       {
43030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43031       };
43032     } catch (Dali::DaliException e) {
43033       {
43034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43035       };
43036     } catch (...) {
43037       {
43038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43039       };
43040     }
43041   }
43042
43043   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43044   return jresult;
43045 }
43046
43047
43048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43049   void * jresult ;
43050   Dali::KeyFrames *result = 0 ;
43051
43052   {
43053     try {
43054       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43055     } catch (std::out_of_range& e) {
43056       {
43057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43058       };
43059     } catch (std::exception& e) {
43060       {
43061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43062       };
43063     } catch (Dali::DaliException e) {
43064       {
43065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43066       };
43067     } catch (...) {
43068       {
43069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43070       };
43071     }
43072   }
43073
43074   jresult = (void *)result;
43075   return jresult;
43076 }
43077
43078
43079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43080   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43081
43082   arg1 = (Dali::KeyFrames *)jarg1;
43083   {
43084     try {
43085       delete arg1;
43086     } catch (std::out_of_range& e) {
43087       {
43088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43089       };
43090     } catch (std::exception& e) {
43091       {
43092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43093       };
43094     } catch (Dali::DaliException e) {
43095       {
43096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43097       };
43098     } catch (...) {
43099       {
43100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43101       };
43102     }
43103   }
43104
43105 }
43106
43107
43108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43109   void * jresult ;
43110   Dali::KeyFrames *arg1 = 0 ;
43111   Dali::KeyFrames *result = 0 ;
43112
43113   arg1 = (Dali::KeyFrames *)jarg1;
43114   if (!arg1) {
43115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43116     return 0;
43117   }
43118   {
43119     try {
43120       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43121     } catch (std::out_of_range& e) {
43122       {
43123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43124       };
43125     } catch (std::exception& e) {
43126       {
43127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43128       };
43129     } catch (Dali::DaliException e) {
43130       {
43131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43132       };
43133     } catch (...) {
43134       {
43135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43136       };
43137     }
43138   }
43139
43140   jresult = (void *)result;
43141   return jresult;
43142 }
43143
43144
43145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43146   void * jresult ;
43147   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43148   Dali::KeyFrames *arg2 = 0 ;
43149   Dali::KeyFrames *result = 0 ;
43150
43151   arg1 = (Dali::KeyFrames *)jarg1;
43152   arg2 = (Dali::KeyFrames *)jarg2;
43153   if (!arg2) {
43154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43155     return 0;
43156   }
43157   {
43158     try {
43159       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43160     } catch (std::out_of_range& e) {
43161       {
43162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43163       };
43164     } catch (std::exception& e) {
43165       {
43166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43167       };
43168     } catch (Dali::DaliException e) {
43169       {
43170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43171       };
43172     } catch (...) {
43173       {
43174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43175       };
43176     }
43177   }
43178
43179   jresult = (void *)result;
43180   return jresult;
43181 }
43182
43183
43184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43185   int jresult ;
43186   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43187   Dali::Property::Type result;
43188
43189   arg1 = (Dali::KeyFrames *)jarg1;
43190   {
43191     try {
43192       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43193     } catch (std::out_of_range& e) {
43194       {
43195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43196       };
43197     } catch (std::exception& e) {
43198       {
43199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43200       };
43201     } catch (Dali::DaliException e) {
43202       {
43203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43204       };
43205     } catch (...) {
43206       {
43207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43208       };
43209     }
43210   }
43211
43212   jresult = (int)result;
43213   return jresult;
43214 }
43215
43216
43217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43218   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43219   float arg2 ;
43220   Dali::Property::Value arg3 ;
43221   Dali::Property::Value *argp3 ;
43222
43223   arg1 = (Dali::KeyFrames *)jarg1;
43224   arg2 = (float)jarg2;
43225   argp3 = (Dali::Property::Value *)jarg3;
43226   if (!argp3) {
43227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43228     return ;
43229   }
43230   arg3 = *argp3;
43231   {
43232     try {
43233       (arg1)->Add(arg2,arg3);
43234     } catch (std::out_of_range& e) {
43235       {
43236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43237       };
43238     } catch (std::exception& e) {
43239       {
43240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43241       };
43242     } catch (Dali::DaliException e) {
43243       {
43244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43245       };
43246     } catch (...) {
43247       {
43248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43249       };
43250     }
43251   }
43252
43253 }
43254
43255
43256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43257   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43258   float arg2 ;
43259   Dali::Property::Value arg3 ;
43260   Dali::AlphaFunction arg4 ;
43261   Dali::Property::Value *argp3 ;
43262   Dali::AlphaFunction *argp4 ;
43263
43264   arg1 = (Dali::KeyFrames *)jarg1;
43265   arg2 = (float)jarg2;
43266   argp3 = (Dali::Property::Value *)jarg3;
43267   if (!argp3) {
43268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43269     return ;
43270   }
43271   arg3 = *argp3;
43272   argp4 = (Dali::AlphaFunction *)jarg4;
43273   if (!argp4) {
43274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43275     return ;
43276   }
43277   arg4 = *argp4;
43278   {
43279     try {
43280       (arg1)->Add(arg2,arg3,arg4);
43281     } catch (std::out_of_range& e) {
43282       {
43283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43284       };
43285     } catch (std::exception& e) {
43286       {
43287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43288       };
43289     } catch (Dali::DaliException e) {
43290       {
43291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43292       };
43293     } catch (...) {
43294       {
43295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43296       };
43297     }
43298   }
43299
43300 }
43301
43302
43303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43304   int jresult ;
43305   int result;
43306
43307   result = (int)Dali::Path::Property::POINTS;
43308   jresult = (int)result;
43309   return jresult;
43310 }
43311
43312
43313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43314   int jresult ;
43315   int result;
43316
43317   result = (int)Dali::Path::Property::CONTROL_POINTS;
43318   jresult = (int)result;
43319   return jresult;
43320 }
43321
43322
43323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43324   void * jresult ;
43325   Dali::Path::Property *result = 0 ;
43326
43327   {
43328     try {
43329       result = (Dali::Path::Property *)new Dali::Path::Property();
43330     } catch (std::out_of_range& e) {
43331       {
43332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43333       };
43334     } catch (std::exception& e) {
43335       {
43336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43337       };
43338     } catch (Dali::DaliException e) {
43339       {
43340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43341       };
43342     } catch (...) {
43343       {
43344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43345       };
43346     }
43347   }
43348
43349   jresult = (void *)result;
43350   return jresult;
43351 }
43352
43353
43354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43355   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43356
43357   arg1 = (Dali::Path::Property *)jarg1;
43358   {
43359     try {
43360       delete arg1;
43361     } catch (std::out_of_range& e) {
43362       {
43363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43364       };
43365     } catch (std::exception& e) {
43366       {
43367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43368       };
43369     } catch (Dali::DaliException e) {
43370       {
43371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43372       };
43373     } catch (...) {
43374       {
43375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43376       };
43377     }
43378   }
43379
43380 }
43381
43382
43383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43384   void * jresult ;
43385   Dali::Path result;
43386
43387   {
43388     try {
43389       result = Dali::Path::New();
43390     } catch (std::out_of_range& e) {
43391       {
43392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43393       };
43394     } catch (std::exception& e) {
43395       {
43396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43397       };
43398     } catch (Dali::DaliException e) {
43399       {
43400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43401       };
43402     } catch (...) {
43403       {
43404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43405       };
43406     }
43407   }
43408
43409   jresult = new Dali::Path((const Dali::Path &)result);
43410   return jresult;
43411 }
43412
43413
43414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43415   void * jresult ;
43416   Dali::BaseHandle arg1 ;
43417   Dali::BaseHandle *argp1 ;
43418   Dali::Path result;
43419
43420   argp1 = (Dali::BaseHandle *)jarg1;
43421   if (!argp1) {
43422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43423     return 0;
43424   }
43425   arg1 = *argp1;
43426   {
43427     try {
43428       result = Dali::Path::DownCast(arg1);
43429     } catch (std::out_of_range& e) {
43430       {
43431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43432       };
43433     } catch (std::exception& e) {
43434       {
43435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43436       };
43437     } catch (Dali::DaliException e) {
43438       {
43439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43440       };
43441     } catch (...) {
43442       {
43443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43444       };
43445     }
43446   }
43447
43448   jresult = new Dali::Path((const Dali::Path &)result);
43449   return jresult;
43450 }
43451
43452
43453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43454   void * jresult ;
43455   Dali::Path *result = 0 ;
43456
43457   {
43458     try {
43459       result = (Dali::Path *)new Dali::Path();
43460     } catch (std::out_of_range& e) {
43461       {
43462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43463       };
43464     } catch (std::exception& e) {
43465       {
43466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43467       };
43468     } catch (Dali::DaliException e) {
43469       {
43470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43471       };
43472     } catch (...) {
43473       {
43474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43475       };
43476     }
43477   }
43478
43479   jresult = (void *)result;
43480   return jresult;
43481 }
43482
43483
43484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43485   Dali::Path *arg1 = (Dali::Path *) 0 ;
43486
43487   arg1 = (Dali::Path *)jarg1;
43488   {
43489     try {
43490       delete arg1;
43491     } catch (std::out_of_range& e) {
43492       {
43493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43494       };
43495     } catch (std::exception& e) {
43496       {
43497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43498       };
43499     } catch (Dali::DaliException e) {
43500       {
43501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43502       };
43503     } catch (...) {
43504       {
43505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43506       };
43507     }
43508   }
43509
43510 }
43511
43512
43513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43514   void * jresult ;
43515   Dali::Path *arg1 = 0 ;
43516   Dali::Path *result = 0 ;
43517
43518   arg1 = (Dali::Path *)jarg1;
43519   if (!arg1) {
43520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43521     return 0;
43522   }
43523   {
43524     try {
43525       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43526     } catch (std::out_of_range& e) {
43527       {
43528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43529       };
43530     } catch (std::exception& e) {
43531       {
43532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43533       };
43534     } catch (Dali::DaliException e) {
43535       {
43536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43537       };
43538     } catch (...) {
43539       {
43540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43541       };
43542     }
43543   }
43544
43545   jresult = (void *)result;
43546   return jresult;
43547 }
43548
43549
43550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43551   void * jresult ;
43552   Dali::Path *arg1 = (Dali::Path *) 0 ;
43553   Dali::Path *arg2 = 0 ;
43554   Dali::Path *result = 0 ;
43555
43556   arg1 = (Dali::Path *)jarg1;
43557   arg2 = (Dali::Path *)jarg2;
43558   if (!arg2) {
43559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43560     return 0;
43561   }
43562   {
43563     try {
43564       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43565     } catch (std::out_of_range& e) {
43566       {
43567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43568       };
43569     } catch (std::exception& e) {
43570       {
43571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43572       };
43573     } catch (Dali::DaliException e) {
43574       {
43575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43576       };
43577     } catch (...) {
43578       {
43579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43580       };
43581     }
43582   }
43583
43584   jresult = (void *)result;
43585   return jresult;
43586 }
43587
43588
43589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43590   Dali::Path *arg1 = (Dali::Path *) 0 ;
43591   Dali::Vector3 *arg2 = 0 ;
43592
43593   arg1 = (Dali::Path *)jarg1;
43594   arg2 = (Dali::Vector3 *)jarg2;
43595   if (!arg2) {
43596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43597     return ;
43598   }
43599   {
43600     try {
43601       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43602     } catch (std::out_of_range& e) {
43603       {
43604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43605       };
43606     } catch (std::exception& e) {
43607       {
43608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43609       };
43610     } catch (Dali::DaliException e) {
43611       {
43612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43613       };
43614     } catch (...) {
43615       {
43616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43617       };
43618     }
43619   }
43620
43621 }
43622
43623
43624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43625   Dali::Path *arg1 = (Dali::Path *) 0 ;
43626   Dali::Vector3 *arg2 = 0 ;
43627
43628   arg1 = (Dali::Path *)jarg1;
43629   arg2 = (Dali::Vector3 *)jarg2;
43630   if (!arg2) {
43631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43632     return ;
43633   }
43634   {
43635     try {
43636       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43637     } catch (std::out_of_range& e) {
43638       {
43639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43640       };
43641     } catch (std::exception& e) {
43642       {
43643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43644       };
43645     } catch (Dali::DaliException e) {
43646       {
43647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43648       };
43649     } catch (...) {
43650       {
43651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43652       };
43653     }
43654   }
43655
43656 }
43657
43658
43659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43660   Dali::Path *arg1 = (Dali::Path *) 0 ;
43661   float arg2 ;
43662
43663   arg1 = (Dali::Path *)jarg1;
43664   arg2 = (float)jarg2;
43665   {
43666     try {
43667       (arg1)->GenerateControlPoints(arg2);
43668     } catch (std::out_of_range& e) {
43669       {
43670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43671       };
43672     } catch (std::exception& e) {
43673       {
43674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43675       };
43676     } catch (Dali::DaliException e) {
43677       {
43678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43679       };
43680     } catch (...) {
43681       {
43682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43683       };
43684     }
43685   }
43686
43687 }
43688
43689
43690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43691   Dali::Path *arg1 = (Dali::Path *) 0 ;
43692   float arg2 ;
43693   Dali::Vector3 *arg3 = 0 ;
43694   Dali::Vector3 *arg4 = 0 ;
43695
43696   arg1 = (Dali::Path *)jarg1;
43697   arg2 = (float)jarg2;
43698   arg3 = (Dali::Vector3 *)jarg3;
43699   if (!arg3) {
43700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43701     return ;
43702   }
43703   arg4 = (Dali::Vector3 *)jarg4;
43704   if (!arg4) {
43705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43706     return ;
43707   }
43708   {
43709     try {
43710       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43711     } catch (std::out_of_range& e) {
43712       {
43713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43714       };
43715     } catch (std::exception& e) {
43716       {
43717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43718       };
43719     } catch (Dali::DaliException e) {
43720       {
43721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43722       };
43723     } catch (...) {
43724       {
43725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43726       };
43727     }
43728   }
43729
43730 }
43731
43732
43733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43734   void * jresult ;
43735   Dali::Path *arg1 = (Dali::Path *) 0 ;
43736   size_t arg2 ;
43737   Dali::Vector3 *result = 0 ;
43738
43739   arg1 = (Dali::Path *)jarg1;
43740   arg2 = (size_t)jarg2;
43741   {
43742     try {
43743       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43744     } catch (std::out_of_range& e) {
43745       {
43746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43747       };
43748     } catch (std::exception& e) {
43749       {
43750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43751       };
43752     } catch (Dali::DaliException e) {
43753       {
43754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43755       };
43756     } catch (...) {
43757       {
43758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43759       };
43760     }
43761   }
43762
43763   jresult = (void *)result;
43764   return jresult;
43765 }
43766
43767
43768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43769   void * jresult ;
43770   Dali::Path *arg1 = (Dali::Path *) 0 ;
43771   size_t arg2 ;
43772   Dali::Vector3 *result = 0 ;
43773
43774   arg1 = (Dali::Path *)jarg1;
43775   arg2 = (size_t)jarg2;
43776   {
43777     try {
43778       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43779     } catch (std::out_of_range& e) {
43780       {
43781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43782       };
43783     } catch (std::exception& e) {
43784       {
43785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43786       };
43787     } catch (Dali::DaliException e) {
43788       {
43789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43790       };
43791     } catch (...) {
43792       {
43793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43794       };
43795     }
43796   }
43797
43798   jresult = (void *)result;
43799   return jresult;
43800 }
43801
43802
43803 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43804   unsigned long jresult ;
43805   Dali::Path *arg1 = (Dali::Path *) 0 ;
43806   size_t result;
43807
43808   arg1 = (Dali::Path *)jarg1;
43809   {
43810     try {
43811       result = ((Dali::Path const *)arg1)->GetPointCount();
43812     } catch (std::out_of_range& e) {
43813       {
43814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43815       };
43816     } catch (std::exception& e) {
43817       {
43818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43819       };
43820     } catch (Dali::DaliException e) {
43821       {
43822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43823       };
43824     } catch (...) {
43825       {
43826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43827       };
43828     }
43829   }
43830
43831   jresult = (unsigned long)result;
43832   return jresult;
43833 }
43834
43835
43836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43837   void * jresult ;
43838   float arg1 ;
43839   Dali::TimePeriod *result = 0 ;
43840
43841   arg1 = (float)jarg1;
43842   {
43843     try {
43844       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43845     } catch (std::out_of_range& e) {
43846       {
43847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43848       };
43849     } catch (std::exception& e) {
43850       {
43851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43852       };
43853     } catch (Dali::DaliException e) {
43854       {
43855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43856       };
43857     } catch (...) {
43858       {
43859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43860       };
43861     }
43862   }
43863
43864   jresult = (void *)result;
43865   return jresult;
43866 }
43867
43868
43869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43870   void * jresult ;
43871   float arg1 ;
43872   float arg2 ;
43873   Dali::TimePeriod *result = 0 ;
43874
43875   arg1 = (float)jarg1;
43876   arg2 = (float)jarg2;
43877   {
43878     try {
43879       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43880     } catch (std::out_of_range& e) {
43881       {
43882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43883       };
43884     } catch (std::exception& e) {
43885       {
43886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43887       };
43888     } catch (Dali::DaliException e) {
43889       {
43890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43891       };
43892     } catch (...) {
43893       {
43894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43895       };
43896     }
43897   }
43898
43899   jresult = (void *)result;
43900   return jresult;
43901 }
43902
43903
43904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43905   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43906
43907   arg1 = (Dali::TimePeriod *)jarg1;
43908   {
43909     try {
43910       delete arg1;
43911     } catch (std::out_of_range& e) {
43912       {
43913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43914       };
43915     } catch (std::exception& e) {
43916       {
43917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43918       };
43919     } catch (Dali::DaliException e) {
43920       {
43921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43922       };
43923     } catch (...) {
43924       {
43925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43926       };
43927     }
43928   }
43929
43930 }
43931
43932
43933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43934   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43935   float arg2 ;
43936
43937   arg1 = (Dali::TimePeriod *)jarg1;
43938   arg2 = (float)jarg2;
43939   if (arg1) (arg1)->delaySeconds = arg2;
43940 }
43941
43942
43943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43944   float jresult ;
43945   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43946   float result;
43947
43948   arg1 = (Dali::TimePeriod *)jarg1;
43949   result = (float) ((arg1)->delaySeconds);
43950   jresult = result;
43951   return jresult;
43952 }
43953
43954
43955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43956   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43957   float arg2 ;
43958
43959   arg1 = (Dali::TimePeriod *)jarg1;
43960   arg2 = (float)jarg2;
43961   if (arg1) (arg1)->durationSeconds = arg2;
43962 }
43963
43964
43965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43966   float jresult ;
43967   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43968   float result;
43969
43970   arg1 = (Dali::TimePeriod *)jarg1;
43971   result = (float) ((arg1)->durationSeconds);
43972   jresult = result;
43973   return jresult;
43974 }
43975
43976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43977   int jresult ;
43978   int result;
43979
43980   result = (int)Dali::LinearConstrainer::Property::VALUE;
43981   jresult = (int)result;
43982   return jresult;
43983 }
43984
43985
43986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43987   int jresult ;
43988   int result;
43989
43990   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43991   jresult = (int)result;
43992   return jresult;
43993 }
43994
43995
43996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43997   void * jresult ;
43998   Dali::LinearConstrainer::Property *result = 0 ;
43999
44000   {
44001     try {
44002       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44003     } catch (std::out_of_range& e) {
44004       {
44005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44006       };
44007     } catch (std::exception& e) {
44008       {
44009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44010       };
44011     } catch (Dali::DaliException e) {
44012       {
44013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44014       };
44015     } catch (...) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44018       };
44019     }
44020   }
44021
44022   jresult = (void *)result;
44023   return jresult;
44024 }
44025
44026
44027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44028   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44029
44030   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44031   {
44032     try {
44033       delete arg1;
44034     } catch (std::out_of_range& e) {
44035       {
44036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44037       };
44038     } catch (std::exception& e) {
44039       {
44040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44041       };
44042     } catch (Dali::DaliException e) {
44043       {
44044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44045       };
44046     } catch (...) {
44047       {
44048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44049       };
44050     }
44051   }
44052
44053 }
44054
44055
44056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44057   void * jresult ;
44058   Dali::LinearConstrainer result;
44059
44060   {
44061     try {
44062       result = Dali::LinearConstrainer::New();
44063     } catch (std::out_of_range& e) {
44064       {
44065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44066       };
44067     } catch (std::exception& e) {
44068       {
44069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44070       };
44071     } catch (Dali::DaliException e) {
44072       {
44073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44074       };
44075     } catch (...) {
44076       {
44077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44078       };
44079     }
44080   }
44081
44082   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44083   return jresult;
44084 }
44085
44086
44087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44088   void * jresult ;
44089   Dali::BaseHandle arg1 ;
44090   Dali::BaseHandle *argp1 ;
44091   Dali::LinearConstrainer result;
44092
44093   argp1 = (Dali::BaseHandle *)jarg1;
44094   if (!argp1) {
44095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44096     return 0;
44097   }
44098   arg1 = *argp1;
44099   {
44100     try {
44101       result = Dali::LinearConstrainer::DownCast(arg1);
44102     } catch (std::out_of_range& e) {
44103       {
44104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44105       };
44106     } catch (std::exception& e) {
44107       {
44108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44109       };
44110     } catch (Dali::DaliException e) {
44111       {
44112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44113       };
44114     } catch (...) {
44115       {
44116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44117       };
44118     }
44119   }
44120
44121   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44122   return jresult;
44123 }
44124
44125
44126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44127   void * jresult ;
44128   Dali::LinearConstrainer *result = 0 ;
44129
44130   {
44131     try {
44132       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44133     } catch (std::out_of_range& e) {
44134       {
44135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44136       };
44137     } catch (std::exception& e) {
44138       {
44139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44140       };
44141     } catch (Dali::DaliException e) {
44142       {
44143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44144       };
44145     } catch (...) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44148       };
44149     }
44150   }
44151
44152   jresult = (void *)result;
44153   return jresult;
44154 }
44155
44156
44157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44158   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44159
44160   arg1 = (Dali::LinearConstrainer *)jarg1;
44161   {
44162     try {
44163       delete arg1;
44164     } catch (std::out_of_range& e) {
44165       {
44166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44167       };
44168     } catch (std::exception& e) {
44169       {
44170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44171       };
44172     } catch (Dali::DaliException e) {
44173       {
44174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44175       };
44176     } catch (...) {
44177       {
44178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44179       };
44180     }
44181   }
44182
44183 }
44184
44185
44186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44187   void * jresult ;
44188   Dali::LinearConstrainer *arg1 = 0 ;
44189   Dali::LinearConstrainer *result = 0 ;
44190
44191   arg1 = (Dali::LinearConstrainer *)jarg1;
44192   if (!arg1) {
44193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44194     return 0;
44195   }
44196   {
44197     try {
44198       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44199     } catch (std::out_of_range& e) {
44200       {
44201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44202       };
44203     } catch (std::exception& e) {
44204       {
44205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44206       };
44207     } catch (Dali::DaliException e) {
44208       {
44209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44210       };
44211     } catch (...) {
44212       {
44213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44214       };
44215     }
44216   }
44217
44218   jresult = (void *)result;
44219   return jresult;
44220 }
44221
44222
44223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44224   void * jresult ;
44225   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44226   Dali::LinearConstrainer *arg2 = 0 ;
44227   Dali::LinearConstrainer *result = 0 ;
44228
44229   arg1 = (Dali::LinearConstrainer *)jarg1;
44230   arg2 = (Dali::LinearConstrainer *)jarg2;
44231   if (!arg2) {
44232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44233     return 0;
44234   }
44235   {
44236     try {
44237       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44238     } catch (std::out_of_range& e) {
44239       {
44240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44241       };
44242     } catch (std::exception& e) {
44243       {
44244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44245       };
44246     } catch (Dali::DaliException e) {
44247       {
44248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44249       };
44250     } catch (...) {
44251       {
44252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44253       };
44254     }
44255   }
44256
44257   jresult = (void *)result;
44258   return jresult;
44259 }
44260
44261
44262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44263   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44264   SwigValueWrapper< Dali::Property > arg2 ;
44265   SwigValueWrapper< Dali::Property > arg3 ;
44266   Dali::Vector2 *arg4 = 0 ;
44267   Dali::Vector2 *arg5 = 0 ;
44268   Dali::Property *argp2 ;
44269   Dali::Property *argp3 ;
44270
44271   arg1 = (Dali::LinearConstrainer *)jarg1;
44272   argp2 = (Dali::Property *)jarg2;
44273   if (!argp2) {
44274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44275     return ;
44276   }
44277   arg2 = *argp2;
44278   argp3 = (Dali::Property *)jarg3;
44279   if (!argp3) {
44280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44281     return ;
44282   }
44283   arg3 = *argp3;
44284   arg4 = (Dali::Vector2 *)jarg4;
44285   if (!arg4) {
44286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44287     return ;
44288   }
44289   arg5 = (Dali::Vector2 *)jarg5;
44290   if (!arg5) {
44291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44292     return ;
44293   }
44294   {
44295     try {
44296       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44297     } catch (std::out_of_range& e) {
44298       {
44299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44300       };
44301     } catch (std::exception& e) {
44302       {
44303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44304       };
44305     } catch (Dali::DaliException e) {
44306       {
44307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44308       };
44309     } catch (...) {
44310       {
44311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44312       };
44313     }
44314   }
44315
44316 }
44317
44318
44319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44320   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44321   SwigValueWrapper< Dali::Property > arg2 ;
44322   SwigValueWrapper< Dali::Property > arg3 ;
44323   Dali::Vector2 *arg4 = 0 ;
44324   Dali::Property *argp2 ;
44325   Dali::Property *argp3 ;
44326
44327   arg1 = (Dali::LinearConstrainer *)jarg1;
44328   argp2 = (Dali::Property *)jarg2;
44329   if (!argp2) {
44330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44331     return ;
44332   }
44333   arg2 = *argp2;
44334   argp3 = (Dali::Property *)jarg3;
44335   if (!argp3) {
44336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44337     return ;
44338   }
44339   arg3 = *argp3;
44340   arg4 = (Dali::Vector2 *)jarg4;
44341   if (!arg4) {
44342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44343     return ;
44344   }
44345   {
44346     try {
44347       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44348     } catch (std::out_of_range& e) {
44349       {
44350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44351       };
44352     } catch (std::exception& e) {
44353       {
44354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44355       };
44356     } catch (Dali::DaliException e) {
44357       {
44358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44359       };
44360     } catch (...) {
44361       {
44362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44363       };
44364     }
44365   }
44366
44367 }
44368
44369
44370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44371   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44372   Dali::Handle *arg2 = 0 ;
44373
44374   arg1 = (Dali::LinearConstrainer *)jarg1;
44375   arg2 = (Dali::Handle *)jarg2;
44376   if (!arg2) {
44377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44378     return ;
44379   }
44380   {
44381     try {
44382       (arg1)->Remove(*arg2);
44383     } catch (std::out_of_range& e) {
44384       {
44385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44386       };
44387     } catch (std::exception& e) {
44388       {
44389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44390       };
44391     } catch (Dali::DaliException e) {
44392       {
44393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44394       };
44395     } catch (...) {
44396       {
44397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44398       };
44399     }
44400   }
44401
44402 }
44403
44404
44405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44406   int jresult ;
44407   int result;
44408
44409   result = (int)Dali::PathConstrainer::Property::FORWARD;
44410   jresult = (int)result;
44411   return jresult;
44412 }
44413
44414
44415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44416   int jresult ;
44417   int result;
44418
44419   result = (int)Dali::PathConstrainer::Property::POINTS;
44420   jresult = (int)result;
44421   return jresult;
44422 }
44423
44424
44425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44426   int jresult ;
44427   int result;
44428
44429   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44430   jresult = (int)result;
44431   return jresult;
44432 }
44433
44434
44435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44436   void * jresult ;
44437   Dali::PathConstrainer::Property *result = 0 ;
44438
44439   {
44440     try {
44441       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44442     } catch (std::out_of_range& e) {
44443       {
44444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44445       };
44446     } catch (std::exception& e) {
44447       {
44448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44449       };
44450     } catch (Dali::DaliException e) {
44451       {
44452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44453       };
44454     } catch (...) {
44455       {
44456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44457       };
44458     }
44459   }
44460
44461   jresult = (void *)result;
44462   return jresult;
44463 }
44464
44465
44466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44467   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44468
44469   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44470   {
44471     try {
44472       delete arg1;
44473     } catch (std::out_of_range& e) {
44474       {
44475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44476       };
44477     } catch (std::exception& e) {
44478       {
44479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44480       };
44481     } catch (Dali::DaliException e) {
44482       {
44483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44484       };
44485     } catch (...) {
44486       {
44487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44488       };
44489     }
44490   }
44491
44492 }
44493
44494
44495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44496   void * jresult ;
44497   Dali::PathConstrainer result;
44498
44499   {
44500     try {
44501       result = Dali::PathConstrainer::New();
44502     } catch (std::out_of_range& e) {
44503       {
44504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44505       };
44506     } catch (std::exception& e) {
44507       {
44508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44509       };
44510     } catch (Dali::DaliException e) {
44511       {
44512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44513       };
44514     } catch (...) {
44515       {
44516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44517       };
44518     }
44519   }
44520
44521   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44522   return jresult;
44523 }
44524
44525
44526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44527   void * jresult ;
44528   Dali::BaseHandle arg1 ;
44529   Dali::BaseHandle *argp1 ;
44530   Dali::PathConstrainer result;
44531
44532   argp1 = (Dali::BaseHandle *)jarg1;
44533   if (!argp1) {
44534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44535     return 0;
44536   }
44537   arg1 = *argp1;
44538   {
44539     try {
44540       result = Dali::PathConstrainer::DownCast(arg1);
44541     } catch (std::out_of_range& e) {
44542       {
44543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44544       };
44545     } catch (std::exception& e) {
44546       {
44547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44548       };
44549     } catch (Dali::DaliException e) {
44550       {
44551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44552       };
44553     } catch (...) {
44554       {
44555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44556       };
44557     }
44558   }
44559
44560   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44561   return jresult;
44562 }
44563
44564
44565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44566   void * jresult ;
44567   Dali::PathConstrainer *result = 0 ;
44568
44569   {
44570     try {
44571       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44572     } catch (std::out_of_range& e) {
44573       {
44574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44575       };
44576     } catch (std::exception& e) {
44577       {
44578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44579       };
44580     } catch (Dali::DaliException e) {
44581       {
44582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44583       };
44584     } catch (...) {
44585       {
44586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44587       };
44588     }
44589   }
44590
44591   jresult = (void *)result;
44592   return jresult;
44593 }
44594
44595
44596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44597   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44598
44599   arg1 = (Dali::PathConstrainer *)jarg1;
44600   {
44601     try {
44602       delete arg1;
44603     } catch (std::out_of_range& e) {
44604       {
44605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44606       };
44607     } catch (std::exception& e) {
44608       {
44609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44610       };
44611     } catch (Dali::DaliException e) {
44612       {
44613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44614       };
44615     } catch (...) {
44616       {
44617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44618       };
44619     }
44620   }
44621
44622 }
44623
44624
44625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44626   void * jresult ;
44627   Dali::PathConstrainer *arg1 = 0 ;
44628   Dali::PathConstrainer *result = 0 ;
44629
44630   arg1 = (Dali::PathConstrainer *)jarg1;
44631   if (!arg1) {
44632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44633     return 0;
44634   }
44635   {
44636     try {
44637       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44638     } catch (std::out_of_range& e) {
44639       {
44640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44641       };
44642     } catch (std::exception& e) {
44643       {
44644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44645       };
44646     } catch (Dali::DaliException e) {
44647       {
44648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44649       };
44650     } catch (...) {
44651       {
44652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44653       };
44654     }
44655   }
44656
44657   jresult = (void *)result;
44658   return jresult;
44659 }
44660
44661
44662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44663   void * jresult ;
44664   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44665   Dali::PathConstrainer *arg2 = 0 ;
44666   Dali::PathConstrainer *result = 0 ;
44667
44668   arg1 = (Dali::PathConstrainer *)jarg1;
44669   arg2 = (Dali::PathConstrainer *)jarg2;
44670   if (!arg2) {
44671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44672     return 0;
44673   }
44674   {
44675     try {
44676       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44677     } catch (std::out_of_range& e) {
44678       {
44679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44680       };
44681     } catch (std::exception& e) {
44682       {
44683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44684       };
44685     } catch (Dali::DaliException e) {
44686       {
44687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44688       };
44689     } catch (...) {
44690       {
44691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44692       };
44693     }
44694   }
44695
44696   jresult = (void *)result;
44697   return jresult;
44698 }
44699
44700
44701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44702   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44703   SwigValueWrapper< Dali::Property > arg2 ;
44704   SwigValueWrapper< Dali::Property > arg3 ;
44705   Dali::Vector2 *arg4 = 0 ;
44706   Dali::Vector2 *arg5 = 0 ;
44707   Dali::Property *argp2 ;
44708   Dali::Property *argp3 ;
44709
44710   arg1 = (Dali::PathConstrainer *)jarg1;
44711   argp2 = (Dali::Property *)jarg2;
44712   if (!argp2) {
44713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44714     return ;
44715   }
44716   arg2 = *argp2;
44717   argp3 = (Dali::Property *)jarg3;
44718   if (!argp3) {
44719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44720     return ;
44721   }
44722   arg3 = *argp3;
44723   arg4 = (Dali::Vector2 *)jarg4;
44724   if (!arg4) {
44725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44726     return ;
44727   }
44728   arg5 = (Dali::Vector2 *)jarg5;
44729   if (!arg5) {
44730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44731     return ;
44732   }
44733   {
44734     try {
44735       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44736     } catch (std::out_of_range& e) {
44737       {
44738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44739       };
44740     } catch (std::exception& e) {
44741       {
44742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44743       };
44744     } catch (Dali::DaliException e) {
44745       {
44746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44747       };
44748     } catch (...) {
44749       {
44750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44751       };
44752     }
44753   }
44754
44755 }
44756
44757
44758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44759   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44760   SwigValueWrapper< Dali::Property > arg2 ;
44761   SwigValueWrapper< Dali::Property > arg3 ;
44762   Dali::Vector2 *arg4 = 0 ;
44763   Dali::Property *argp2 ;
44764   Dali::Property *argp3 ;
44765
44766   arg1 = (Dali::PathConstrainer *)jarg1;
44767   argp2 = (Dali::Property *)jarg2;
44768   if (!argp2) {
44769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44770     return ;
44771   }
44772   arg2 = *argp2;
44773   argp3 = (Dali::Property *)jarg3;
44774   if (!argp3) {
44775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44776     return ;
44777   }
44778   arg3 = *argp3;
44779   arg4 = (Dali::Vector2 *)jarg4;
44780   if (!arg4) {
44781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44782     return ;
44783   }
44784   {
44785     try {
44786       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44787     } catch (std::out_of_range& e) {
44788       {
44789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44790       };
44791     } catch (std::exception& e) {
44792       {
44793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44794       };
44795     } catch (Dali::DaliException e) {
44796       {
44797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44798       };
44799     } catch (...) {
44800       {
44801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44802       };
44803     }
44804   }
44805
44806 }
44807
44808
44809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44810   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44811   Dali::Handle *arg2 = 0 ;
44812
44813   arg1 = (Dali::PathConstrainer *)jarg1;
44814   arg2 = (Dali::Handle *)jarg2;
44815   if (!arg2) {
44816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44817     return ;
44818   }
44819   {
44820     try {
44821       (arg1)->Remove(*arg2);
44822     } catch (std::out_of_range& e) {
44823       {
44824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44825       };
44826     } catch (std::exception& e) {
44827       {
44828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44829       };
44830     } catch (Dali::DaliException e) {
44831       {
44832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44833       };
44834     } catch (...) {
44835       {
44836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44837       };
44838     }
44839   }
44840
44841 }
44842
44843
44844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44845   int jresult ;
44846   Dali::FittingMode::Type result;
44847
44848   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44849   jresult = (int)result;
44850   return jresult;
44851 }
44852
44853
44854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44855   int jresult ;
44856   Dali::SamplingMode::Type result;
44857
44858   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44859   jresult = (int)result;
44860   return jresult;
44861 }
44862
44863
44864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
44865   void * jresult ;
44866   Dali::NativeImage *result = 0 ;
44867
44868   {
44869     try {
44870       result = (Dali::NativeImage *)new Dali::NativeImage();
44871     } catch (std::out_of_range& e) {
44872       {
44873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44874       };
44875     } catch (std::exception& e) {
44876       {
44877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44878       };
44879     } catch (Dali::DaliException e) {
44880       {
44881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44882       };
44883     } catch (...) {
44884       {
44885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44886       };
44887     }
44888   }
44889
44890   jresult = (void *)result;
44891   return jresult;
44892 }
44893
44894
44895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
44896   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
44897
44898   arg1 = (Dali::NativeImage *)jarg1;
44899   {
44900     try {
44901       delete arg1;
44902     } catch (std::out_of_range& e) {
44903       {
44904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44905       };
44906     } catch (std::exception& e) {
44907       {
44908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44909       };
44910     } catch (Dali::DaliException e) {
44911       {
44912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44913       };
44914     } catch (...) {
44915       {
44916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44917       };
44918     }
44919   }
44920
44921 }
44922
44923
44924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
44925   void * jresult ;
44926   Dali::NativeImage *arg1 = 0 ;
44927   Dali::NativeImage *result = 0 ;
44928
44929   arg1 = (Dali::NativeImage *)jarg1;
44930   if (!arg1) {
44931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
44932     return 0;
44933   }
44934   {
44935     try {
44936       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
44937     } catch (std::out_of_range& e) {
44938       {
44939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44940       };
44941     } catch (std::exception& e) {
44942       {
44943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44944       };
44945     } catch (Dali::DaliException e) {
44946       {
44947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44948       };
44949     } catch (...) {
44950       {
44951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44952       };
44953     }
44954   }
44955
44956   jresult = (void *)result;
44957   return jresult;
44958 }
44959
44960
44961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
44962   void * jresult ;
44963   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
44964   Dali::NativeImage *arg2 = 0 ;
44965   Dali::NativeImage *result = 0 ;
44966
44967   arg1 = (Dali::NativeImage *)jarg1;
44968   arg2 = (Dali::NativeImage *)jarg2;
44969   if (!arg2) {
44970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
44971     return 0;
44972   }
44973   {
44974     try {
44975       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
44976     } catch (std::out_of_range& e) {
44977       {
44978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44979       };
44980     } catch (std::exception& e) {
44981       {
44982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44983       };
44984     } catch (Dali::DaliException e) {
44985       {
44986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44987       };
44988     } catch (...) {
44989       {
44990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44991       };
44992     }
44993   }
44994
44995   jresult = (void *)result;
44996   return jresult;
44997 }
44998
44999
45000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
45001   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45002
45003   arg1 = (Dali::NativeImage *)jarg1;
45004   {
45005     try {
45006       (arg1)->CreateGlTexture();
45007     } catch (std::out_of_range& e) {
45008       {
45009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45010       };
45011     } catch (std::exception& e) {
45012       {
45013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45014       };
45015     } catch (Dali::DaliException e) {
45016       {
45017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45018       };
45019     } catch (...) {
45020       {
45021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45022       };
45023     }
45024   }
45025
45026 }
45027
45028
45029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
45030   void * jresult ;
45031   NativeImageInterface *arg1 = 0 ;
45032   Dali::NativeImage result;
45033
45034   arg1 = (NativeImageInterface *)jarg1;
45035   if (!arg1) {
45036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
45037     return 0;
45038   }
45039   {
45040     try {
45041       result = Dali::NativeImage::New(*arg1);
45042     } catch (std::out_of_range& e) {
45043       {
45044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45045       };
45046     } catch (std::exception& e) {
45047       {
45048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45049       };
45050     } catch (Dali::DaliException e) {
45051       {
45052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45053       };
45054     } catch (...) {
45055       {
45056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45057       };
45058     }
45059   }
45060
45061   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45062   return jresult;
45063 }
45064
45065
45066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
45067   void * jresult ;
45068   Dali::BaseHandle arg1 ;
45069   Dali::BaseHandle *argp1 ;
45070   Dali::NativeImage result;
45071
45072   argp1 = (Dali::BaseHandle *)jarg1;
45073   if (!argp1) {
45074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45075     return 0;
45076   }
45077   arg1 = *argp1;
45078   {
45079     try {
45080       result = Dali::NativeImage::DownCast(arg1);
45081     } catch (std::out_of_range& e) {
45082       {
45083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45084       };
45085     } catch (std::exception& e) {
45086       {
45087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45088       };
45089     } catch (Dali::DaliException e) {
45090       {
45091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45092       };
45093     } catch (...) {
45094       {
45095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45096       };
45097     }
45098   }
45099
45100   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45101   return jresult;
45102 }
45103
45104
45105 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
45106   char * jresult ;
45107   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45108   char *result = 0 ;
45109
45110   arg1 = (Dali::NativeImage *)jarg1;
45111   {
45112     try {
45113       result = (char *)(arg1)->GetCustomFragmentPreFix();
45114     } catch (std::out_of_range& e) {
45115       {
45116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45117       };
45118     } catch (std::exception& e) {
45119       {
45120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45121       };
45122     } catch (Dali::DaliException e) {
45123       {
45124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45125       };
45126     } catch (...) {
45127       {
45128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45129       };
45130     }
45131   }
45132
45133   jresult = SWIG_csharp_string_callback((const char *)result);
45134   return jresult;
45135 }
45136
45137
45138 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
45139   char * jresult ;
45140   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45141   char *result = 0 ;
45142
45143   arg1 = (Dali::NativeImage *)jarg1;
45144   {
45145     try {
45146       result = (char *)(arg1)->GetCustomSamplerTypename();
45147     } catch (std::out_of_range& e) {
45148       {
45149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45150       };
45151     } catch (std::exception& e) {
45152       {
45153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45154       };
45155     } catch (Dali::DaliException e) {
45156       {
45157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45158       };
45159     } catch (...) {
45160       {
45161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45162       };
45163     }
45164   }
45165
45166   jresult = SWIG_csharp_string_callback((const char *)result);
45167   return jresult;
45168 }
45169
45170
45171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
45172   unsigned int jresult ;
45173   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45174   bool result;
45175
45176   arg1 = (Dali::NativeImageInterface *)jarg1;
45177   {
45178     try {
45179       result = (bool)(arg1)->GlExtensionCreate();
45180     } catch (std::out_of_range& e) {
45181       {
45182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45183       };
45184     } catch (std::exception& e) {
45185       {
45186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45187       };
45188     } catch (Dali::DaliException e) {
45189       {
45190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45191       };
45192     } catch (...) {
45193       {
45194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45195       };
45196     }
45197   }
45198
45199   jresult = result;
45200   return jresult;
45201 }
45202
45203
45204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
45205   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45206
45207   arg1 = (Dali::NativeImageInterface *)jarg1;
45208   {
45209     try {
45210       (arg1)->GlExtensionDestroy();
45211     } catch (std::out_of_range& e) {
45212       {
45213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45214       };
45215     } catch (std::exception& e) {
45216       {
45217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45218       };
45219     } catch (Dali::DaliException e) {
45220       {
45221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45222       };
45223     } catch (...) {
45224       {
45225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45226       };
45227     }
45228   }
45229
45230 }
45231
45232
45233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
45234   unsigned int jresult ;
45235   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45236   unsigned int result;
45237
45238   arg1 = (Dali::NativeImageInterface *)jarg1;
45239   {
45240     try {
45241       result = (unsigned int)(arg1)->TargetTexture();
45242     } catch (std::out_of_range& e) {
45243       {
45244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45245       };
45246     } catch (std::exception& e) {
45247       {
45248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45249       };
45250     } catch (Dali::DaliException e) {
45251       {
45252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45253       };
45254     } catch (...) {
45255       {
45256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45257       };
45258     }
45259   }
45260
45261   jresult = result;
45262   return jresult;
45263 }
45264
45265
45266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
45267   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45268
45269   arg1 = (Dali::NativeImageInterface *)jarg1;
45270   {
45271     try {
45272       (arg1)->PrepareTexture();
45273     } catch (std::out_of_range& e) {
45274       {
45275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45276       };
45277     } catch (std::exception& e) {
45278       {
45279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45280       };
45281     } catch (Dali::DaliException e) {
45282       {
45283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45284       };
45285     } catch (...) {
45286       {
45287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45288       };
45289     }
45290   }
45291
45292 }
45293
45294
45295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
45296   unsigned int jresult ;
45297   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45298   unsigned int result;
45299
45300   arg1 = (Dali::NativeImageInterface *)jarg1;
45301   {
45302     try {
45303       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
45304     } catch (std::out_of_range& e) {
45305       {
45306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45307       };
45308     } catch (std::exception& e) {
45309       {
45310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45311       };
45312     } catch (Dali::DaliException e) {
45313       {
45314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45315       };
45316     } catch (...) {
45317       {
45318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45319       };
45320     }
45321   }
45322
45323   jresult = result;
45324   return jresult;
45325 }
45326
45327
45328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
45329   unsigned int jresult ;
45330   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45331   unsigned int result;
45332
45333   arg1 = (Dali::NativeImageInterface *)jarg1;
45334   {
45335     try {
45336       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
45337     } catch (std::out_of_range& e) {
45338       {
45339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45340       };
45341     } catch (std::exception& e) {
45342       {
45343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45344       };
45345     } catch (Dali::DaliException e) {
45346       {
45347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45348       };
45349     } catch (...) {
45350       {
45351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45352       };
45353     }
45354   }
45355
45356   jresult = result;
45357   return jresult;
45358 }
45359
45360
45361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
45362   unsigned int jresult ;
45363   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45364   bool result;
45365
45366   arg1 = (Dali::NativeImageInterface *)jarg1;
45367   {
45368     try {
45369       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
45370     } catch (std::out_of_range& e) {
45371       {
45372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45373       };
45374     } catch (std::exception& e) {
45375       {
45376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45377       };
45378     } catch (Dali::DaliException e) {
45379       {
45380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45381       };
45382     } catch (...) {
45383       {
45384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45385       };
45386     }
45387   }
45388
45389   jresult = result;
45390   return jresult;
45391 }
45392
45393
45394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
45395   void * jresult ;
45396   std::string *arg1 = 0 ;
45397   Dali::ImageDimensions result;
45398
45399   if (!jarg1) {
45400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45401     return 0;
45402   }
45403   std::string arg1_str(jarg1);
45404   arg1 = &arg1_str;
45405   {
45406     try {
45407       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
45408     } catch (std::out_of_range& e) {
45409       {
45410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45411       };
45412     } catch (std::exception& e) {
45413       {
45414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45415       };
45416     } catch (Dali::DaliException e) {
45417       {
45418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45419       };
45420     } catch (...) {
45421       {
45422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45423       };
45424     }
45425   }
45426
45427   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
45428
45429   //argout typemap for const std::string&
45430
45431   return jresult;
45432 }
45433
45434
45435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
45436   void * jresult ;
45437   Dali::ResourceImage *result = 0 ;
45438
45439   {
45440     try {
45441       result = (Dali::ResourceImage *)new Dali::ResourceImage();
45442     } catch (std::out_of_range& e) {
45443       {
45444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45445       };
45446     } catch (std::exception& e) {
45447       {
45448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45449       };
45450     } catch (Dali::DaliException e) {
45451       {
45452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45453       };
45454     } catch (...) {
45455       {
45456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45457       };
45458     }
45459   }
45460
45461   jresult = (void *)result;
45462   return jresult;
45463 }
45464
45465
45466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
45467   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45468
45469   arg1 = (Dali::ResourceImage *)jarg1;
45470   {
45471     try {
45472       delete arg1;
45473     } catch (std::out_of_range& e) {
45474       {
45475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45476       };
45477     } catch (std::exception& e) {
45478       {
45479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45480       };
45481     } catch (Dali::DaliException e) {
45482       {
45483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45484       };
45485     } catch (...) {
45486       {
45487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45488       };
45489     }
45490   }
45491
45492 }
45493
45494
45495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
45496   void * jresult ;
45497   Dali::ResourceImage *arg1 = 0 ;
45498   Dali::ResourceImage *result = 0 ;
45499
45500   arg1 = (Dali::ResourceImage *)jarg1;
45501   if (!arg1) {
45502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
45503     return 0;
45504   }
45505   {
45506     try {
45507       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
45508     } catch (std::out_of_range& e) {
45509       {
45510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45511       };
45512     } catch (std::exception& e) {
45513       {
45514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45515       };
45516     } catch (Dali::DaliException e) {
45517       {
45518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45519       };
45520     } catch (...) {
45521       {
45522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45523       };
45524     }
45525   }
45526
45527   jresult = (void *)result;
45528   return jresult;
45529 }
45530
45531
45532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
45533   void * jresult ;
45534   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45535   Dali::ResourceImage *arg2 = 0 ;
45536   Dali::ResourceImage *result = 0 ;
45537
45538   arg1 = (Dali::ResourceImage *)jarg1;
45539   arg2 = (Dali::ResourceImage *)jarg2;
45540   if (!arg2) {
45541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
45542     return 0;
45543   }
45544   {
45545     try {
45546       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
45547     } catch (std::out_of_range& e) {
45548       {
45549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45550       };
45551     } catch (std::exception& e) {
45552       {
45553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45554       };
45555     } catch (Dali::DaliException e) {
45556       {
45557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45558       };
45559     } catch (...) {
45560       {
45561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45562       };
45563     }
45564   }
45565
45566   jresult = (void *)result;
45567   return jresult;
45568 }
45569
45570
45571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
45572   void * jresult ;
45573   std::string *arg1 = 0 ;
45574   bool arg2 ;
45575   Dali::ResourceImage result;
45576
45577   if (!jarg1) {
45578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45579     return 0;
45580   }
45581   std::string arg1_str(jarg1);
45582   arg1 = &arg1_str;
45583   arg2 = jarg2 ? true : false;
45584   {
45585     try {
45586       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
45587     } catch (std::out_of_range& e) {
45588       {
45589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45590       };
45591     } catch (std::exception& e) {
45592       {
45593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45594       };
45595     } catch (Dali::DaliException e) {
45596       {
45597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45598       };
45599     } catch (...) {
45600       {
45601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45602       };
45603     }
45604   }
45605
45606   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45607
45608   //argout typemap for const std::string&
45609
45610   return jresult;
45611 }
45612
45613
45614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
45615   void * jresult ;
45616   std::string *arg1 = 0 ;
45617   Dali::ResourceImage result;
45618
45619   if (!jarg1) {
45620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45621     return 0;
45622   }
45623   std::string arg1_str(jarg1);
45624   arg1 = &arg1_str;
45625   {
45626     try {
45627       result = Dali::ResourceImage::New((std::string const &)*arg1);
45628     } catch (std::out_of_range& e) {
45629       {
45630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45631       };
45632     } catch (std::exception& e) {
45633       {
45634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45635       };
45636     } catch (Dali::DaliException e) {
45637       {
45638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45639       };
45640     } catch (...) {
45641       {
45642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45643       };
45644     }
45645   }
45646
45647   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45648
45649   //argout typemap for const std::string&
45650
45651   return jresult;
45652 }
45653
45654
45655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
45656   void * jresult ;
45657   std::string *arg1 = 0 ;
45658   Dali::ImageDimensions arg2 ;
45659   Dali::FittingMode::Type arg3 ;
45660   Dali::SamplingMode::Type arg4 ;
45661   bool arg5 ;
45662   Dali::ImageDimensions *argp2 ;
45663   Dali::ResourceImage result;
45664
45665   if (!jarg1) {
45666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45667     return 0;
45668   }
45669   std::string arg1_str(jarg1);
45670   arg1 = &arg1_str;
45671   argp2 = (Dali::ImageDimensions *)jarg2;
45672   if (!argp2) {
45673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45674     return 0;
45675   }
45676   arg2 = *argp2;
45677   arg3 = (Dali::FittingMode::Type)jarg3;
45678   arg4 = (Dali::SamplingMode::Type)jarg4;
45679   arg5 = jarg5 ? true : false;
45680   {
45681     try {
45682       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
45683     } catch (std::out_of_range& e) {
45684       {
45685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45686       };
45687     } catch (std::exception& e) {
45688       {
45689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45690       };
45691     } catch (Dali::DaliException e) {
45692       {
45693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45694       };
45695     } catch (...) {
45696       {
45697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45698       };
45699     }
45700   }
45701
45702   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45703
45704   //argout typemap for const std::string&
45705
45706   return jresult;
45707 }
45708
45709
45710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
45711   void * jresult ;
45712   std::string *arg1 = 0 ;
45713   Dali::ImageDimensions arg2 ;
45714   Dali::FittingMode::Type arg3 ;
45715   Dali::SamplingMode::Type arg4 ;
45716   Dali::ImageDimensions *argp2 ;
45717   Dali::ResourceImage result;
45718
45719   if (!jarg1) {
45720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45721     return 0;
45722   }
45723   std::string arg1_str(jarg1);
45724   arg1 = &arg1_str;
45725   argp2 = (Dali::ImageDimensions *)jarg2;
45726   if (!argp2) {
45727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45728     return 0;
45729   }
45730   arg2 = *argp2;
45731   arg3 = (Dali::FittingMode::Type)jarg3;
45732   arg4 = (Dali::SamplingMode::Type)jarg4;
45733   {
45734     try {
45735       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
45736     } catch (std::out_of_range& e) {
45737       {
45738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45739       };
45740     } catch (std::exception& e) {
45741       {
45742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45743       };
45744     } catch (Dali::DaliException e) {
45745       {
45746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45747       };
45748     } catch (...) {
45749       {
45750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45751       };
45752     }
45753   }
45754
45755   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45756
45757   //argout typemap for const std::string&
45758
45759   return jresult;
45760 }
45761
45762
45763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
45764   void * jresult ;
45765   std::string *arg1 = 0 ;
45766   Dali::ImageDimensions arg2 ;
45767   Dali::FittingMode::Type arg3 ;
45768   Dali::ImageDimensions *argp2 ;
45769   Dali::ResourceImage result;
45770
45771   if (!jarg1) {
45772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45773     return 0;
45774   }
45775   std::string arg1_str(jarg1);
45776   arg1 = &arg1_str;
45777   argp2 = (Dali::ImageDimensions *)jarg2;
45778   if (!argp2) {
45779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45780     return 0;
45781   }
45782   arg2 = *argp2;
45783   arg3 = (Dali::FittingMode::Type)jarg3;
45784   {
45785     try {
45786       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
45787     } catch (std::out_of_range& e) {
45788       {
45789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45790       };
45791     } catch (std::exception& e) {
45792       {
45793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45794       };
45795     } catch (Dali::DaliException e) {
45796       {
45797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45798       };
45799     } catch (...) {
45800       {
45801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45802       };
45803     }
45804   }
45805
45806   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45807
45808   //argout typemap for const std::string&
45809
45810   return jresult;
45811 }
45812
45813
45814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
45815   void * jresult ;
45816   std::string *arg1 = 0 ;
45817   Dali::ImageDimensions arg2 ;
45818   Dali::ImageDimensions *argp2 ;
45819   Dali::ResourceImage result;
45820
45821   if (!jarg1) {
45822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45823     return 0;
45824   }
45825   std::string arg1_str(jarg1);
45826   arg1 = &arg1_str;
45827   argp2 = (Dali::ImageDimensions *)jarg2;
45828   if (!argp2) {
45829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45830     return 0;
45831   }
45832   arg2 = *argp2;
45833   {
45834     try {
45835       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
45836     } catch (std::out_of_range& e) {
45837       {
45838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45839       };
45840     } catch (std::exception& e) {
45841       {
45842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45843       };
45844     } catch (Dali::DaliException e) {
45845       {
45846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45847       };
45848     } catch (...) {
45849       {
45850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45851       };
45852     }
45853   }
45854
45855   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45856
45857   //argout typemap for const std::string&
45858
45859   return jresult;
45860 }
45861
45862
45863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
45864   void * jresult ;
45865   Dali::BaseHandle arg1 ;
45866   Dali::BaseHandle *argp1 ;
45867   Dali::ResourceImage result;
45868
45869   argp1 = (Dali::BaseHandle *)jarg1;
45870   if (!argp1) {
45871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45872     return 0;
45873   }
45874   arg1 = *argp1;
45875   {
45876     try {
45877       result = Dali::ResourceImage::DownCast(arg1);
45878     } catch (std::out_of_range& e) {
45879       {
45880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45881       };
45882     } catch (std::exception& e) {
45883       {
45884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45885       };
45886     } catch (Dali::DaliException e) {
45887       {
45888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45889       };
45890     } catch (...) {
45891       {
45892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45893       };
45894     }
45895   }
45896
45897   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45898   return jresult;
45899 }
45900
45901
45902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
45903   int jresult ;
45904   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45905   Dali::LoadingState result;
45906
45907   arg1 = (Dali::ResourceImage *)jarg1;
45908   {
45909     try {
45910       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
45911     } catch (std::out_of_range& e) {
45912       {
45913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45914       };
45915     } catch (std::exception& e) {
45916       {
45917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45918       };
45919     } catch (Dali::DaliException e) {
45920       {
45921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45922       };
45923     } catch (...) {
45924       {
45925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45926       };
45927     }
45928   }
45929
45930   jresult = (int)result;
45931   return jresult;
45932 }
45933
45934
45935 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
45936   char * jresult ;
45937   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45938   std::string result;
45939
45940   arg1 = (Dali::ResourceImage *)jarg1;
45941   {
45942     try {
45943       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
45944     } catch (std::out_of_range& e) {
45945       {
45946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45947       };
45948     } catch (std::exception& e) {
45949       {
45950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45951       };
45952     } catch (Dali::DaliException e) {
45953       {
45954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45955       };
45956     } catch (...) {
45957       {
45958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45959       };
45960     }
45961   }
45962
45963   jresult = SWIG_csharp_string_callback((&result)->c_str());
45964   return jresult;
45965 }
45966
45967
45968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
45969   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45970
45971   arg1 = (Dali::ResourceImage *)jarg1;
45972   {
45973     try {
45974       (arg1)->Reload();
45975     } catch (std::out_of_range& e) {
45976       {
45977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45978       };
45979     } catch (std::exception& e) {
45980       {
45981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45982       };
45983     } catch (Dali::DaliException e) {
45984       {
45985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45986       };
45987     } catch (...) {
45988       {
45989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45990       };
45991     }
45992   }
45993
45994 }
45995
45996
45997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
45998   void * jresult ;
45999   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46000   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
46001
46002   arg1 = (Dali::ResourceImage *)jarg1;
46003   {
46004     try {
46005       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
46006     } catch (std::out_of_range& e) {
46007       {
46008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46009       };
46010     } catch (std::exception& e) {
46011       {
46012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46013       };
46014     } catch (Dali::DaliException e) {
46015       {
46016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46017       };
46018     } catch (...) {
46019       {
46020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46021       };
46022     }
46023   }
46024
46025   jresult = (void *)result;
46026   return jresult;
46027 }
46028
46029
46030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
46031   void * jresult ;
46032   Dali::FrameBufferImage *result = 0 ;
46033
46034   {
46035     try {
46036       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
46037     } catch (std::out_of_range& e) {
46038       {
46039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46040       };
46041     } catch (std::exception& e) {
46042       {
46043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46044       };
46045     } catch (Dali::DaliException e) {
46046       {
46047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46048       };
46049     } catch (...) {
46050       {
46051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46052       };
46053     }
46054   }
46055
46056   jresult = (void *)result;
46057   return jresult;
46058 }
46059
46060
46061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
46062   void * jresult ;
46063   unsigned int arg1 ;
46064   unsigned int arg2 ;
46065   Dali::Pixel::Format arg3 ;
46066   Dali::RenderBuffer::Format arg4 ;
46067   Dali::FrameBufferImage result;
46068
46069   arg1 = (unsigned int)jarg1;
46070   arg2 = (unsigned int)jarg2;
46071   arg3 = (Dali::Pixel::Format)jarg3;
46072   arg4 = (Dali::RenderBuffer::Format)jarg4;
46073   {
46074     try {
46075       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
46076     } catch (std::out_of_range& e) {
46077       {
46078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46079       };
46080     } catch (std::exception& e) {
46081       {
46082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46083       };
46084     } catch (Dali::DaliException e) {
46085       {
46086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46087       };
46088     } catch (...) {
46089       {
46090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46091       };
46092     }
46093   }
46094
46095   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46096   return jresult;
46097 }
46098
46099
46100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
46101   void * jresult ;
46102   unsigned int arg1 ;
46103   unsigned int arg2 ;
46104   Dali::Pixel::Format arg3 ;
46105   Dali::FrameBufferImage result;
46106
46107   arg1 = (unsigned int)jarg1;
46108   arg2 = (unsigned int)jarg2;
46109   arg3 = (Dali::Pixel::Format)jarg3;
46110   {
46111     try {
46112       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
46113     } catch (std::out_of_range& e) {
46114       {
46115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46116       };
46117     } catch (std::exception& e) {
46118       {
46119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46120       };
46121     } catch (Dali::DaliException e) {
46122       {
46123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46124       };
46125     } catch (...) {
46126       {
46127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46128       };
46129     }
46130   }
46131
46132   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46133   return jresult;
46134 }
46135
46136
46137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
46138   void * jresult ;
46139   unsigned int arg1 ;
46140   unsigned int arg2 ;
46141   Dali::FrameBufferImage result;
46142
46143   arg1 = (unsigned int)jarg1;
46144   arg2 = (unsigned int)jarg2;
46145   {
46146     try {
46147       result = Dali::FrameBufferImage::New(arg1,arg2);
46148     } catch (std::out_of_range& e) {
46149       {
46150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46151       };
46152     } catch (std::exception& e) {
46153       {
46154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46155       };
46156     } catch (Dali::DaliException e) {
46157       {
46158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46159       };
46160     } catch (...) {
46161       {
46162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46163       };
46164     }
46165   }
46166
46167   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46168   return jresult;
46169 }
46170
46171
46172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
46173   void * jresult ;
46174   unsigned int arg1 ;
46175   Dali::FrameBufferImage result;
46176
46177   arg1 = (unsigned int)jarg1;
46178   {
46179     try {
46180       result = Dali::FrameBufferImage::New(arg1);
46181     } catch (std::out_of_range& e) {
46182       {
46183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46184       };
46185     } catch (std::exception& e) {
46186       {
46187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46188       };
46189     } catch (Dali::DaliException e) {
46190       {
46191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46192       };
46193     } catch (...) {
46194       {
46195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46196       };
46197     }
46198   }
46199
46200   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46201   return jresult;
46202 }
46203
46204
46205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
46206   void * jresult ;
46207   Dali::FrameBufferImage result;
46208
46209   {
46210     try {
46211       result = Dali::FrameBufferImage::New();
46212     } catch (std::out_of_range& e) {
46213       {
46214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46215       };
46216     } catch (std::exception& e) {
46217       {
46218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46219       };
46220     } catch (Dali::DaliException e) {
46221       {
46222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46223       };
46224     } catch (...) {
46225       {
46226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46227       };
46228     }
46229   }
46230
46231   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46232   return jresult;
46233 }
46234
46235
46236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
46237   void * jresult ;
46238   Dali::NativeImageInterface *arg1 = 0 ;
46239   Dali::FrameBufferImage result;
46240
46241   arg1 = (Dali::NativeImageInterface *)jarg1;
46242   if (!arg1) {
46243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
46244     return 0;
46245   }
46246   {
46247     try {
46248       result = Dali::FrameBufferImage::New(*arg1);
46249     } catch (std::out_of_range& e) {
46250       {
46251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46252       };
46253     } catch (std::exception& e) {
46254       {
46255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46256       };
46257     } catch (Dali::DaliException e) {
46258       {
46259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46260       };
46261     } catch (...) {
46262       {
46263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46264       };
46265     }
46266   }
46267
46268   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46269   return jresult;
46270 }
46271
46272
46273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
46274   void * jresult ;
46275   Dali::BaseHandle arg1 ;
46276   Dali::BaseHandle *argp1 ;
46277   Dali::FrameBufferImage result;
46278
46279   argp1 = (Dali::BaseHandle *)jarg1;
46280   if (!argp1) {
46281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46282     return 0;
46283   }
46284   arg1 = *argp1;
46285   {
46286     try {
46287       result = Dali::FrameBufferImage::DownCast(arg1);
46288     } catch (std::out_of_range& e) {
46289       {
46290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46291       };
46292     } catch (std::exception& e) {
46293       {
46294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46295       };
46296     } catch (Dali::DaliException e) {
46297       {
46298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46299       };
46300     } catch (...) {
46301       {
46302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46303       };
46304     }
46305   }
46306
46307   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46308   return jresult;
46309 }
46310
46311
46312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
46313   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
46314
46315   arg1 = (Dali::FrameBufferImage *)jarg1;
46316   {
46317     try {
46318       delete arg1;
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_new_FrameBufferImage__SWIG_1(void * jarg1) {
46342   void * jresult ;
46343   Dali::FrameBufferImage *arg1 = 0 ;
46344   Dali::FrameBufferImage *result = 0 ;
46345
46346   arg1 = (Dali::FrameBufferImage *)jarg1;
46347   if (!arg1) {
46348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
46349     return 0;
46350   }
46351   {
46352     try {
46353       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
46354     } catch (std::out_of_range& e) {
46355       {
46356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46357       };
46358     } catch (std::exception& e) {
46359       {
46360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46361       };
46362     } catch (Dali::DaliException e) {
46363       {
46364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46365       };
46366     } catch (...) {
46367       {
46368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46369       };
46370     }
46371   }
46372
46373   jresult = (void *)result;
46374   return jresult;
46375 }
46376
46377
46378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
46379   void * jresult ;
46380   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
46381   Dali::FrameBufferImage *arg2 = 0 ;
46382   Dali::FrameBufferImage *result = 0 ;
46383
46384   arg1 = (Dali::FrameBufferImage *)jarg1;
46385   arg2 = (Dali::FrameBufferImage *)jarg2;
46386   if (!arg2) {
46387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
46388     return 0;
46389   }
46390   {
46391     try {
46392       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
46393     } catch (std::out_of_range& e) {
46394       {
46395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46396       };
46397     } catch (std::exception& e) {
46398       {
46399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46400       };
46401     } catch (Dali::DaliException e) {
46402       {
46403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46404       };
46405     } catch (...) {
46406       {
46407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46408       };
46409     }
46410   }
46411
46412   jresult = (void *)result;
46413   return jresult;
46414 }
46415
46416
46417 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
46418   int jresult ;
46419   int result;
46420
46421   result = (int)Dali::CameraActor::Property::TYPE;
46422   jresult = (int)result;
46423   return jresult;
46424 }
46425
46426
46427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
46428   int jresult ;
46429   int result;
46430
46431   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
46432   jresult = (int)result;
46433   return jresult;
46434 }
46435
46436
46437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
46438   int jresult ;
46439   int result;
46440
46441   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
46442   jresult = (int)result;
46443   return jresult;
46444 }
46445
46446
46447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
46448   int jresult ;
46449   int result;
46450
46451   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
46452   jresult = (int)result;
46453   return jresult;
46454 }
46455
46456
46457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
46458   int jresult ;
46459   int result;
46460
46461   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
46462   jresult = (int)result;
46463   return jresult;
46464 }
46465
46466
46467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
46468   int jresult ;
46469   int result;
46470
46471   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
46472   jresult = (int)result;
46473   return jresult;
46474 }
46475
46476
46477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
46478   int jresult ;
46479   int result;
46480
46481   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
46482   jresult = (int)result;
46483   return jresult;
46484 }
46485
46486
46487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
46488   int jresult ;
46489   int result;
46490
46491   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
46492   jresult = (int)result;
46493   return jresult;
46494 }
46495
46496
46497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
46498   int jresult ;
46499   int result;
46500
46501   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
46502   jresult = (int)result;
46503   return jresult;
46504 }
46505
46506
46507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
46508   int jresult ;
46509   int result;
46510
46511   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
46512   jresult = (int)result;
46513   return jresult;
46514 }
46515
46516
46517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
46518   int jresult ;
46519   int result;
46520
46521   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
46522   jresult = (int)result;
46523   return jresult;
46524 }
46525
46526
46527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
46528   int jresult ;
46529   int result;
46530
46531   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
46532   jresult = (int)result;
46533   return jresult;
46534 }
46535
46536
46537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
46538   int jresult ;
46539   int result;
46540
46541   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
46542   jresult = (int)result;
46543   return jresult;
46544 }
46545
46546
46547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
46548   int jresult ;
46549   int result;
46550
46551   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
46552   jresult = (int)result;
46553   return jresult;
46554 }
46555
46556
46557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
46558   void * jresult ;
46559   Dali::CameraActor::Property *result = 0 ;
46560
46561   {
46562     try {
46563       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
46564     } catch (std::out_of_range& e) {
46565       {
46566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46567       };
46568     } catch (std::exception& e) {
46569       {
46570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46571       };
46572     } catch (Dali::DaliException e) {
46573       {
46574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46575       };
46576     } catch (...) {
46577       {
46578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46579       };
46580     }
46581   }
46582
46583   jresult = (void *)result;
46584   return jresult;
46585 }
46586
46587
46588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
46589   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
46590
46591   arg1 = (Dali::CameraActor::Property *)jarg1;
46592   {
46593     try {
46594       delete arg1;
46595     } catch (std::out_of_range& e) {
46596       {
46597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46598       };
46599     } catch (std::exception& e) {
46600       {
46601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46602       };
46603     } catch (Dali::DaliException e) {
46604       {
46605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46606       };
46607     } catch (...) {
46608       {
46609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46610       };
46611     }
46612   }
46613
46614 }
46615
46616
46617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
46618   void * jresult ;
46619   Dali::CameraActor *result = 0 ;
46620
46621   {
46622     try {
46623       result = (Dali::CameraActor *)new Dali::CameraActor();
46624     } catch (std::out_of_range& e) {
46625       {
46626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46627       };
46628     } catch (std::exception& e) {
46629       {
46630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46631       };
46632     } catch (Dali::DaliException e) {
46633       {
46634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46635       };
46636     } catch (...) {
46637       {
46638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46639       };
46640     }
46641   }
46642
46643   jresult = (void *)result;
46644   return jresult;
46645 }
46646
46647
46648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
46649   void * jresult ;
46650   Dali::CameraActor result;
46651
46652   {
46653     try {
46654       result = Dali::CameraActor::New();
46655     } catch (std::out_of_range& e) {
46656       {
46657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46658       };
46659     } catch (std::exception& e) {
46660       {
46661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46662       };
46663     } catch (Dali::DaliException e) {
46664       {
46665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46666       };
46667     } catch (...) {
46668       {
46669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46670       };
46671     }
46672   }
46673
46674   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
46675   return jresult;
46676 }
46677
46678
46679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
46680   void * jresult ;
46681   Dali::Size *arg1 = 0 ;
46682   Dali::CameraActor result;
46683
46684   arg1 = (Dali::Size *)jarg1;
46685   if (!arg1) {
46686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
46687     return 0;
46688   }
46689   {
46690     try {
46691       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
46692     } catch (std::out_of_range& e) {
46693       {
46694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46695       };
46696     } catch (std::exception& e) {
46697       {
46698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46699       };
46700     } catch (Dali::DaliException e) {
46701       {
46702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46703       };
46704     } catch (...) {
46705       {
46706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46707       };
46708     }
46709   }
46710
46711   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
46712   return jresult;
46713 }
46714
46715
46716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
46717   void * jresult ;
46718   Dali::BaseHandle arg1 ;
46719   Dali::BaseHandle *argp1 ;
46720   Dali::CameraActor result;
46721
46722   argp1 = (Dali::BaseHandle *)jarg1;
46723   if (!argp1) {
46724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46725     return 0;
46726   }
46727   arg1 = *argp1;
46728   {
46729     try {
46730       result = Dali::CameraActor::DownCast(arg1);
46731     } catch (std::out_of_range& e) {
46732       {
46733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46734       };
46735     } catch (std::exception& e) {
46736       {
46737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46738       };
46739     } catch (Dali::DaliException e) {
46740       {
46741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46742       };
46743     } catch (...) {
46744       {
46745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46746       };
46747     }
46748   }
46749
46750   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
46751   return jresult;
46752 }
46753
46754
46755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
46756   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46757
46758   arg1 = (Dali::CameraActor *)jarg1;
46759   {
46760     try {
46761       delete arg1;
46762     } catch (std::out_of_range& e) {
46763       {
46764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46765       };
46766     } catch (std::exception& e) {
46767       {
46768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46769       };
46770     } catch (Dali::DaliException e) {
46771       {
46772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46773       };
46774     } catch (...) {
46775       {
46776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46777       };
46778     }
46779   }
46780
46781 }
46782
46783
46784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
46785   void * jresult ;
46786   Dali::CameraActor *arg1 = 0 ;
46787   Dali::CameraActor *result = 0 ;
46788
46789   arg1 = (Dali::CameraActor *)jarg1;
46790   if (!arg1) {
46791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
46792     return 0;
46793   }
46794   {
46795     try {
46796       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
46797     } catch (std::out_of_range& e) {
46798       {
46799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46800       };
46801     } catch (std::exception& e) {
46802       {
46803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46804       };
46805     } catch (Dali::DaliException e) {
46806       {
46807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46808       };
46809     } catch (...) {
46810       {
46811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46812       };
46813     }
46814   }
46815
46816   jresult = (void *)result;
46817   return jresult;
46818 }
46819
46820
46821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
46822   void * jresult ;
46823   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46824   Dali::CameraActor *arg2 = 0 ;
46825   Dali::CameraActor *result = 0 ;
46826
46827   arg1 = (Dali::CameraActor *)jarg1;
46828   arg2 = (Dali::CameraActor *)jarg2;
46829   if (!arg2) {
46830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
46831     return 0;
46832   }
46833   {
46834     try {
46835       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
46836     } catch (std::out_of_range& e) {
46837       {
46838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46839       };
46840     } catch (std::exception& e) {
46841       {
46842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46843       };
46844     } catch (Dali::DaliException e) {
46845       {
46846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46847       };
46848     } catch (...) {
46849       {
46850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46851       };
46852     }
46853   }
46854
46855   jresult = (void *)result;
46856   return jresult;
46857 }
46858
46859
46860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
46861   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46862   Dali::Camera::Type arg2 ;
46863
46864   arg1 = (Dali::CameraActor *)jarg1;
46865   arg2 = (Dali::Camera::Type)jarg2;
46866   {
46867     try {
46868       (arg1)->SetType(arg2);
46869     } catch (std::out_of_range& e) {
46870       {
46871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46872       };
46873     } catch (std::exception& e) {
46874       {
46875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46876       };
46877     } catch (Dali::DaliException e) {
46878       {
46879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46880       };
46881     } catch (...) {
46882       {
46883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46884       };
46885     }
46886   }
46887
46888 }
46889
46890
46891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
46892   int jresult ;
46893   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46894   Dali::Camera::Type result;
46895
46896   arg1 = (Dali::CameraActor *)jarg1;
46897   {
46898     try {
46899       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
46900     } catch (std::out_of_range& e) {
46901       {
46902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46903       };
46904     } catch (std::exception& e) {
46905       {
46906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46907       };
46908     } catch (Dali::DaliException e) {
46909       {
46910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46911       };
46912     } catch (...) {
46913       {
46914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46915       };
46916     }
46917   }
46918
46919   jresult = (int)result;
46920   return jresult;
46921 }
46922
46923
46924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
46925   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46926   Dali::Camera::ProjectionMode arg2 ;
46927
46928   arg1 = (Dali::CameraActor *)jarg1;
46929   arg2 = (Dali::Camera::ProjectionMode)jarg2;
46930   {
46931     try {
46932       (arg1)->SetProjectionMode(arg2);
46933     } catch (std::out_of_range& e) {
46934       {
46935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46936       };
46937     } catch (std::exception& e) {
46938       {
46939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46940       };
46941     } catch (Dali::DaliException e) {
46942       {
46943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46944       };
46945     } catch (...) {
46946       {
46947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46948       };
46949     }
46950   }
46951
46952 }
46953
46954
46955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
46956   int jresult ;
46957   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46958   Dali::Camera::ProjectionMode result;
46959
46960   arg1 = (Dali::CameraActor *)jarg1;
46961   {
46962     try {
46963       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
46964     } catch (std::out_of_range& e) {
46965       {
46966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46967       };
46968     } catch (std::exception& e) {
46969       {
46970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46971       };
46972     } catch (Dali::DaliException e) {
46973       {
46974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46975       };
46976     } catch (...) {
46977       {
46978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46979       };
46980     }
46981   }
46982
46983   jresult = (int)result;
46984   return jresult;
46985 }
46986
46987
46988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
46989   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
46990   float arg2 ;
46991
46992   arg1 = (Dali::CameraActor *)jarg1;
46993   arg2 = (float)jarg2;
46994   {
46995     try {
46996       (arg1)->SetFieldOfView(arg2);
46997     } catch (std::out_of_range& e) {
46998       {
46999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47000       };
47001     } catch (std::exception& e) {
47002       {
47003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47004       };
47005     } catch (Dali::DaliException e) {
47006       {
47007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47008       };
47009     } catch (...) {
47010       {
47011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47012       };
47013     }
47014   }
47015
47016 }
47017
47018
47019 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
47020   float jresult ;
47021   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47022   float result;
47023
47024   arg1 = (Dali::CameraActor *)jarg1;
47025   {
47026     try {
47027       result = (float)(arg1)->GetFieldOfView();
47028     } catch (std::out_of_range& e) {
47029       {
47030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47031       };
47032     } catch (std::exception& e) {
47033       {
47034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47035       };
47036     } catch (Dali::DaliException e) {
47037       {
47038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47039       };
47040     } catch (...) {
47041       {
47042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47043       };
47044     }
47045   }
47046
47047   jresult = result;
47048   return jresult;
47049 }
47050
47051
47052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
47053   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47054   float arg2 ;
47055
47056   arg1 = (Dali::CameraActor *)jarg1;
47057   arg2 = (float)jarg2;
47058   {
47059     try {
47060       (arg1)->SetAspectRatio(arg2);
47061     } catch (std::out_of_range& e) {
47062       {
47063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47064       };
47065     } catch (std::exception& e) {
47066       {
47067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47068       };
47069     } catch (Dali::DaliException e) {
47070       {
47071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47072       };
47073     } catch (...) {
47074       {
47075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47076       };
47077     }
47078   }
47079
47080 }
47081
47082
47083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
47084   float jresult ;
47085   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47086   float result;
47087
47088   arg1 = (Dali::CameraActor *)jarg1;
47089   {
47090     try {
47091       result = (float)(arg1)->GetAspectRatio();
47092     } catch (std::out_of_range& e) {
47093       {
47094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47095       };
47096     } catch (std::exception& e) {
47097       {
47098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47099       };
47100     } catch (Dali::DaliException e) {
47101       {
47102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47103       };
47104     } catch (...) {
47105       {
47106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47107       };
47108     }
47109   }
47110
47111   jresult = result;
47112   return jresult;
47113 }
47114
47115
47116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
47117   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47118   float arg2 ;
47119
47120   arg1 = (Dali::CameraActor *)jarg1;
47121   arg2 = (float)jarg2;
47122   {
47123     try {
47124       (arg1)->SetNearClippingPlane(arg2);
47125     } catch (std::out_of_range& e) {
47126       {
47127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47128       };
47129     } catch (std::exception& e) {
47130       {
47131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47132       };
47133     } catch (Dali::DaliException e) {
47134       {
47135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47136       };
47137     } catch (...) {
47138       {
47139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47140       };
47141     }
47142   }
47143
47144 }
47145
47146
47147 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
47148   float jresult ;
47149   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47150   float result;
47151
47152   arg1 = (Dali::CameraActor *)jarg1;
47153   {
47154     try {
47155       result = (float)(arg1)->GetNearClippingPlane();
47156     } catch (std::out_of_range& e) {
47157       {
47158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47159       };
47160     } catch (std::exception& e) {
47161       {
47162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47163       };
47164     } catch (Dali::DaliException e) {
47165       {
47166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47167       };
47168     } catch (...) {
47169       {
47170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47171       };
47172     }
47173   }
47174
47175   jresult = result;
47176   return jresult;
47177 }
47178
47179
47180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
47181   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47182   float arg2 ;
47183
47184   arg1 = (Dali::CameraActor *)jarg1;
47185   arg2 = (float)jarg2;
47186   {
47187     try {
47188       (arg1)->SetFarClippingPlane(arg2);
47189     } catch (std::out_of_range& e) {
47190       {
47191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47192       };
47193     } catch (std::exception& e) {
47194       {
47195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47196       };
47197     } catch (Dali::DaliException e) {
47198       {
47199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47200       };
47201     } catch (...) {
47202       {
47203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47204       };
47205     }
47206   }
47207
47208 }
47209
47210
47211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
47212   float jresult ;
47213   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47214   float result;
47215
47216   arg1 = (Dali::CameraActor *)jarg1;
47217   {
47218     try {
47219       result = (float)(arg1)->GetFarClippingPlane();
47220     } catch (std::out_of_range& e) {
47221       {
47222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47223       };
47224     } catch (std::exception& e) {
47225       {
47226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47227       };
47228     } catch (Dali::DaliException e) {
47229       {
47230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47231       };
47232     } catch (...) {
47233       {
47234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47235       };
47236     }
47237   }
47238
47239   jresult = result;
47240   return jresult;
47241 }
47242
47243
47244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
47245   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47246   Dali::Vector3 *arg2 = 0 ;
47247
47248   arg1 = (Dali::CameraActor *)jarg1;
47249   arg2 = (Dali::Vector3 *)jarg2;
47250   if (!arg2) {
47251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
47252     return ;
47253   }
47254   {
47255     try {
47256       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
47257     } catch (std::out_of_range& e) {
47258       {
47259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47260       };
47261     } catch (std::exception& e) {
47262       {
47263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47264       };
47265     } catch (Dali::DaliException e) {
47266       {
47267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47268       };
47269     } catch (...) {
47270       {
47271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47272       };
47273     }
47274   }
47275
47276 }
47277
47278
47279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
47280   void * jresult ;
47281   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47282   Dali::Vector3 result;
47283
47284   arg1 = (Dali::CameraActor *)jarg1;
47285   {
47286     try {
47287       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
47288     } catch (std::out_of_range& e) {
47289       {
47290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47291       };
47292     } catch (std::exception& e) {
47293       {
47294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47295       };
47296     } catch (Dali::DaliException e) {
47297       {
47298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47299       };
47300     } catch (...) {
47301       {
47302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47303       };
47304     }
47305   }
47306
47307   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
47308   return jresult;
47309 }
47310
47311
47312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
47313   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47314   bool arg2 ;
47315
47316   arg1 = (Dali::CameraActor *)jarg1;
47317   arg2 = jarg2 ? true : false;
47318   {
47319     try {
47320       (arg1)->SetInvertYAxis(arg2);
47321     } catch (std::out_of_range& e) {
47322       {
47323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47324       };
47325     } catch (std::exception& e) {
47326       {
47327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47328       };
47329     } catch (Dali::DaliException e) {
47330       {
47331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47332       };
47333     } catch (...) {
47334       {
47335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47336       };
47337     }
47338   }
47339
47340 }
47341
47342
47343 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
47344   unsigned int jresult ;
47345   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47346   bool result;
47347
47348   arg1 = (Dali::CameraActor *)jarg1;
47349   {
47350     try {
47351       result = (bool)(arg1)->GetInvertYAxis();
47352     } catch (std::out_of_range& e) {
47353       {
47354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47355       };
47356     } catch (std::exception& e) {
47357       {
47358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47359       };
47360     } catch (Dali::DaliException e) {
47361       {
47362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47363       };
47364     } catch (...) {
47365       {
47366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47367       };
47368     }
47369   }
47370
47371   jresult = result;
47372   return jresult;
47373 }
47374
47375
47376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
47377   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47378   Dali::Size *arg2 = 0 ;
47379
47380   arg1 = (Dali::CameraActor *)jarg1;
47381   arg2 = (Dali::Size *)jarg2;
47382   if (!arg2) {
47383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
47384     return ;
47385   }
47386   {
47387     try {
47388       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
47389     } catch (std::out_of_range& e) {
47390       {
47391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47392       };
47393     } catch (std::exception& e) {
47394       {
47395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47396       };
47397     } catch (Dali::DaliException e) {
47398       {
47399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47400       };
47401     } catch (...) {
47402       {
47403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47404       };
47405     }
47406   }
47407
47408 }
47409
47410
47411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
47412   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47413   Dali::Size *arg2 = 0 ;
47414
47415   arg1 = (Dali::CameraActor *)jarg1;
47416   arg2 = (Dali::Size *)jarg2;
47417   if (!arg2) {
47418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
47419     return ;
47420   }
47421   {
47422     try {
47423       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
47424     } catch (std::out_of_range& e) {
47425       {
47426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47427       };
47428     } catch (std::exception& e) {
47429       {
47430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47431       };
47432     } catch (Dali::DaliException e) {
47433       {
47434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47435       };
47436     } catch (...) {
47437       {
47438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47439       };
47440     }
47441   }
47442
47443 }
47444
47445
47446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
47447   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47448   float arg2 ;
47449   float arg3 ;
47450   float arg4 ;
47451   float arg5 ;
47452   float arg6 ;
47453   float arg7 ;
47454
47455   arg1 = (Dali::CameraActor *)jarg1;
47456   arg2 = (float)jarg2;
47457   arg3 = (float)jarg3;
47458   arg4 = (float)jarg4;
47459   arg5 = (float)jarg5;
47460   arg6 = (float)jarg6;
47461   arg7 = (float)jarg7;
47462   {
47463     try {
47464       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
47465     } catch (std::out_of_range& e) {
47466       {
47467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47468       };
47469     } catch (std::exception& e) {
47470       {
47471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47472       };
47473     } catch (Dali::DaliException e) {
47474       {
47475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47476       };
47477     } catch (...) {
47478       {
47479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47480       };
47481     }
47482   }
47483
47484 }
47485
47486
47487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
47488   void * jresult ;
47489   std::pair< std::string,Dali::Property::Value > *result = 0 ;
47490
47491   {
47492     try {
47493       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
47494     } catch (std::out_of_range& e) {
47495       {
47496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47497       };
47498     } catch (std::exception& e) {
47499       {
47500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47501       };
47502     } catch (Dali::DaliException e) {
47503       {
47504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47505       };
47506     } catch (...) {
47507       {
47508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47509       };
47510     }
47511   }
47512
47513   jresult = (void *)result;
47514   return jresult;
47515 }
47516
47517
47518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
47519   void * jresult ;
47520   std::string arg1 ;
47521   Dali::Property::Value arg2 ;
47522   Dali::Property::Value *argp2 ;
47523   std::pair< std::string,Dali::Property::Value > *result = 0 ;
47524
47525   if (!jarg1) {
47526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47527     return 0;
47528   }
47529   (&arg1)->assign(jarg1);
47530   argp2 = (Dali::Property::Value *)jarg2;
47531   if (!argp2) {
47532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
47533     return 0;
47534   }
47535   arg2 = *argp2;
47536   {
47537     try {
47538       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
47539     } catch (std::out_of_range& e) {
47540       {
47541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47542       };
47543     } catch (std::exception& e) {
47544       {
47545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47546       };
47547     } catch (Dali::DaliException e) {
47548       {
47549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47550       };
47551     } catch (...) {
47552       {
47553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47554       };
47555     }
47556   }
47557
47558   jresult = (void *)result;
47559   return jresult;
47560 }
47561
47562
47563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
47564   void * jresult ;
47565   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
47566   std::pair< std::string,Dali::Property::Value > *result = 0 ;
47567
47568   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47569   if (!arg1) {
47570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
47571     return 0;
47572   }
47573   {
47574     try {
47575       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);
47576     } catch (std::out_of_range& e) {
47577       {
47578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47579       };
47580     } catch (std::exception& e) {
47581       {
47582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47583       };
47584     } catch (Dali::DaliException e) {
47585       {
47586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47587       };
47588     } catch (...) {
47589       {
47590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47591       };
47592     }
47593   }
47594
47595   jresult = (void *)result;
47596   return jresult;
47597 }
47598
47599
47600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
47601   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
47602   std::string *arg2 = 0 ;
47603
47604   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47605   if (!jarg2) {
47606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47607     return ;
47608   }
47609   std::string arg2_str(jarg2);
47610   arg2 = &arg2_str;
47611   if (arg1) (arg1)->first = *arg2;
47612
47613   //argout typemap for const std::string&
47614
47615 }
47616
47617
47618 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
47619   char * jresult ;
47620   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
47621   std::string *result = 0 ;
47622
47623   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47624   result = (std::string *) & ((arg1)->first);
47625   jresult = SWIG_csharp_string_callback(result->c_str());
47626   return jresult;
47627 }
47628
47629
47630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
47631   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
47632   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
47633
47634   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47635   arg2 = (Dali::Property::Value *)jarg2;
47636   if (arg1) (arg1)->second = *arg2;
47637 }
47638
47639
47640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
47641   void * jresult ;
47642   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
47643   Dali::Property::Value *result = 0 ;
47644
47645   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47646   result = (Dali::Property::Value *)& ((arg1)->second);
47647   jresult = (void *)result;
47648   return jresult;
47649 }
47650
47651
47652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
47653   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
47654
47655   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47656   {
47657     try {
47658       delete arg1;
47659     } catch (std::out_of_range& e) {
47660       {
47661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47662       };
47663     } catch (std::exception& e) {
47664       {
47665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47666       };
47667     } catch (Dali::DaliException e) {
47668       {
47669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47670       };
47671     } catch (...) {
47672       {
47673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47674       };
47675     }
47676   }
47677
47678 }
47679
47680
47681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
47682   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47683
47684   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47685   {
47686     try {
47687       (arg1)->clear();
47688     } catch (std::out_of_range& e) {
47689       {
47690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47691       };
47692     } catch (std::exception& e) {
47693       {
47694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47695       };
47696     } catch (Dali::DaliException e) {
47697       {
47698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47699       };
47700     } catch (...) {
47701       {
47702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47703       };
47704     }
47705   }
47706
47707 }
47708
47709
47710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
47711   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47712   Dali::TouchPoint *arg2 = 0 ;
47713
47714   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47715   arg2 = (Dali::TouchPoint *)jarg2;
47716   if (!arg2) {
47717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
47718     return ;
47719   }
47720   {
47721     try {
47722       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
47723     } catch (std::out_of_range& e) {
47724       {
47725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47726       };
47727     } catch (std::exception& e) {
47728       {
47729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47730       };
47731     } catch (Dali::DaliException e) {
47732       {
47733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47734       };
47735     } catch (...) {
47736       {
47737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47738       };
47739     }
47740   }
47741
47742 }
47743
47744
47745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
47746   unsigned long jresult ;
47747   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47748   std::vector< Dali::TouchPoint >::size_type result;
47749
47750   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47751   {
47752     try {
47753       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
47754     } catch (std::out_of_range& e) {
47755       {
47756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47757       };
47758     } catch (std::exception& e) {
47759       {
47760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47761       };
47762     } catch (Dali::DaliException e) {
47763       {
47764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47765       };
47766     } catch (...) {
47767       {
47768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47769       };
47770     }
47771   }
47772
47773   jresult = (unsigned long)result;
47774   return jresult;
47775 }
47776
47777
47778 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
47779   unsigned long jresult ;
47780   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47781   std::vector< Dali::TouchPoint >::size_type result;
47782
47783   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47784   {
47785     try {
47786       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
47787     } catch (std::out_of_range& e) {
47788       {
47789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47790       };
47791     } catch (std::exception& e) {
47792       {
47793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47794       };
47795     } catch (Dali::DaliException e) {
47796       {
47797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47798       };
47799     } catch (...) {
47800       {
47801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47802       };
47803     }
47804   }
47805
47806   jresult = (unsigned long)result;
47807   return jresult;
47808 }
47809
47810
47811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
47812   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47813   std::vector< Dali::TouchPoint >::size_type arg2 ;
47814
47815   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47816   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
47817   {
47818     try {
47819       (arg1)->reserve(arg2);
47820     } catch (std::out_of_range& e) {
47821       {
47822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47823       };
47824     } catch (std::exception& e) {
47825       {
47826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47827       };
47828     } catch (Dali::DaliException e) {
47829       {
47830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47831       };
47832     } catch (...) {
47833       {
47834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47835       };
47836     }
47837   }
47838
47839 }
47840
47841
47842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
47843   void * jresult ;
47844   std::vector< Dali::TouchPoint > *result = 0 ;
47845
47846   {
47847     try {
47848       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
47849     } catch (std::out_of_range& e) {
47850       {
47851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47852       };
47853     } catch (std::exception& e) {
47854       {
47855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47856       };
47857     } catch (Dali::DaliException e) {
47858       {
47859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47860       };
47861     } catch (...) {
47862       {
47863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47864       };
47865     }
47866   }
47867
47868   jresult = (void *)result;
47869   return jresult;
47870 }
47871
47872
47873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
47874   void * jresult ;
47875   std::vector< Dali::TouchPoint > *arg1 = 0 ;
47876   std::vector< Dali::TouchPoint > *result = 0 ;
47877
47878   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47879   if (!arg1) {
47880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
47881     return 0;
47882   }
47883   {
47884     try {
47885       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
47886     } catch (std::out_of_range& e) {
47887       {
47888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47889       };
47890     } catch (std::exception& e) {
47891       {
47892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47893       };
47894     } catch (Dali::DaliException e) {
47895       {
47896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47897       };
47898     } catch (...) {
47899       {
47900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47901       };
47902     }
47903   }
47904
47905   jresult = (void *)result;
47906   return jresult;
47907 }
47908
47909
47910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
47911   void * jresult ;
47912   int arg1 ;
47913   std::vector< Dali::TouchPoint > *result = 0 ;
47914
47915   arg1 = (int)jarg1;
47916   {
47917     try {
47918       try {
47919         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
47920       }
47921       catch(std::out_of_range &_e) {
47922         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47923         return 0;
47924       }
47925
47926     } catch (std::out_of_range& e) {
47927       {
47928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47929       };
47930     } catch (std::exception& e) {
47931       {
47932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47933       };
47934     } catch (Dali::DaliException e) {
47935       {
47936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47937       };
47938     } catch (...) {
47939       {
47940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47941       };
47942     }
47943   }
47944
47945   jresult = (void *)result;
47946   return jresult;
47947 }
47948
47949
47950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
47951   void * jresult ;
47952   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47953   int arg2 ;
47954   SwigValueWrapper< Dali::TouchPoint > result;
47955
47956   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47957   arg2 = (int)jarg2;
47958   {
47959     try {
47960       try {
47961         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
47962       }
47963       catch(std::out_of_range &_e) {
47964         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47965         return 0;
47966       }
47967
47968     } catch (std::out_of_range& e) {
47969       {
47970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47971       };
47972     } catch (std::exception& e) {
47973       {
47974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47975       };
47976     } catch (Dali::DaliException e) {
47977       {
47978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47979       };
47980     } catch (...) {
47981       {
47982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47983       };
47984     }
47985   }
47986
47987   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
47988   return jresult;
47989 }
47990
47991
47992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
47993   void * jresult ;
47994   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47995   int arg2 ;
47996   Dali::TouchPoint *result = 0 ;
47997
47998   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47999   arg2 = (int)jarg2;
48000   {
48001     try {
48002       try {
48003         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
48004       }
48005       catch(std::out_of_range &_e) {
48006         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48007         return 0;
48008       }
48009
48010     } catch (std::out_of_range& e) {
48011       {
48012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48013       };
48014     } catch (std::exception& e) {
48015       {
48016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48017       };
48018     } catch (Dali::DaliException e) {
48019       {
48020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48021       };
48022     } catch (...) {
48023       {
48024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48025       };
48026     }
48027   }
48028
48029   jresult = (void *)result;
48030   return jresult;
48031 }
48032
48033
48034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
48035   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48036   int arg2 ;
48037   Dali::TouchPoint *arg3 = 0 ;
48038
48039   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48040   arg2 = (int)jarg2;
48041   arg3 = (Dali::TouchPoint *)jarg3;
48042   if (!arg3) {
48043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
48044     return ;
48045   }
48046   {
48047     try {
48048       try {
48049         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
48050       }
48051       catch(std::out_of_range &_e) {
48052         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48053         return ;
48054       }
48055
48056     } catch (std::out_of_range& e) {
48057       {
48058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48059       };
48060     } catch (std::exception& e) {
48061       {
48062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48063       };
48064     } catch (Dali::DaliException e) {
48065       {
48066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48067       };
48068     } catch (...) {
48069       {
48070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48071       };
48072     }
48073   }
48074
48075 }
48076
48077
48078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
48079   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48080   std::vector< Dali::TouchPoint > *arg2 = 0 ;
48081
48082   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48083   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
48084   if (!arg2) {
48085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
48086     return ;
48087   }
48088   {
48089     try {
48090       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
48091     } catch (std::out_of_range& e) {
48092       {
48093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48094       };
48095     } catch (std::exception& e) {
48096       {
48097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48098       };
48099     } catch (Dali::DaliException e) {
48100       {
48101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48102       };
48103     } catch (...) {
48104       {
48105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48106       };
48107     }
48108   }
48109
48110 }
48111
48112
48113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
48114   void * jresult ;
48115   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48116   int arg2 ;
48117   int arg3 ;
48118   std::vector< Dali::TouchPoint > *result = 0 ;
48119
48120   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48121   arg2 = (int)jarg2;
48122   arg3 = (int)jarg3;
48123   {
48124     try {
48125       try {
48126         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
48127       }
48128       catch(std::out_of_range &_e) {
48129         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48130         return 0;
48131       }
48132       catch(std::invalid_argument &_e) {
48133         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
48134         return 0;
48135       }
48136
48137     } catch (std::out_of_range& e) {
48138       {
48139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48140       };
48141     } catch (std::exception& e) {
48142       {
48143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48144       };
48145     } catch (Dali::DaliException e) {
48146       {
48147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48148       };
48149     } catch (...) {
48150       {
48151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48152       };
48153     }
48154   }
48155
48156   jresult = (void *)result;
48157   return jresult;
48158 }
48159
48160
48161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
48162   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48163   int arg2 ;
48164   Dali::TouchPoint *arg3 = 0 ;
48165
48166   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48167   arg2 = (int)jarg2;
48168   arg3 = (Dali::TouchPoint *)jarg3;
48169   if (!arg3) {
48170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
48171     return ;
48172   }
48173   {
48174     try {
48175       try {
48176         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
48177       }
48178       catch(std::out_of_range &_e) {
48179         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48180         return ;
48181       }
48182
48183     } catch (std::out_of_range& e) {
48184       {
48185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48186       };
48187     } catch (std::exception& e) {
48188       {
48189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48190       };
48191     } catch (Dali::DaliException e) {
48192       {
48193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48194       };
48195     } catch (...) {
48196       {
48197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48198       };
48199     }
48200   }
48201
48202 }
48203
48204
48205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
48206   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48207   int arg2 ;
48208   std::vector< Dali::TouchPoint > *arg3 = 0 ;
48209
48210   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48211   arg2 = (int)jarg2;
48212   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
48213   if (!arg3) {
48214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
48215     return ;
48216   }
48217   {
48218     try {
48219       try {
48220         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
48221       }
48222       catch(std::out_of_range &_e) {
48223         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48224         return ;
48225       }
48226
48227     } catch (std::out_of_range& e) {
48228       {
48229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48230       };
48231     } catch (std::exception& e) {
48232       {
48233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48234       };
48235     } catch (Dali::DaliException e) {
48236       {
48237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48238       };
48239     } catch (...) {
48240       {
48241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48242       };
48243     }
48244   }
48245
48246 }
48247
48248
48249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
48250   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48251   int arg2 ;
48252
48253   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48254   arg2 = (int)jarg2;
48255   {
48256     try {
48257       try {
48258         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
48259       }
48260       catch(std::out_of_range &_e) {
48261         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48262         return ;
48263       }
48264
48265     } catch (std::out_of_range& e) {
48266       {
48267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48268       };
48269     } catch (std::exception& e) {
48270       {
48271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48272       };
48273     } catch (Dali::DaliException e) {
48274       {
48275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48276       };
48277     } catch (...) {
48278       {
48279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48280       };
48281     }
48282   }
48283
48284 }
48285
48286
48287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
48288   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48289   int arg2 ;
48290   int arg3 ;
48291
48292   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48293   arg2 = (int)jarg2;
48294   arg3 = (int)jarg3;
48295   {
48296     try {
48297       try {
48298         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
48299       }
48300       catch(std::out_of_range &_e) {
48301         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48302         return ;
48303       }
48304       catch(std::invalid_argument &_e) {
48305         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
48306         return ;
48307       }
48308
48309     } catch (std::out_of_range& e) {
48310       {
48311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48312       };
48313     } catch (std::exception& e) {
48314       {
48315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48316       };
48317     } catch (Dali::DaliException e) {
48318       {
48319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48320       };
48321     } catch (...) {
48322       {
48323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48324       };
48325     }
48326   }
48327
48328 }
48329
48330
48331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
48332   void * jresult ;
48333   Dali::TouchPoint *arg1 = 0 ;
48334   int arg2 ;
48335   std::vector< Dali::TouchPoint > *result = 0 ;
48336
48337   arg1 = (Dali::TouchPoint *)jarg1;
48338   if (!arg1) {
48339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
48340     return 0;
48341   }
48342   arg2 = (int)jarg2;
48343   {
48344     try {
48345       try {
48346         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
48347       }
48348       catch(std::out_of_range &_e) {
48349         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48350         return 0;
48351       }
48352
48353     } catch (std::out_of_range& e) {
48354       {
48355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48356       };
48357     } catch (std::exception& e) {
48358       {
48359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48360       };
48361     } catch (Dali::DaliException e) {
48362       {
48363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48364       };
48365     } catch (...) {
48366       {
48367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48368       };
48369     }
48370   }
48371
48372   jresult = (void *)result;
48373   return jresult;
48374 }
48375
48376
48377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
48378   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48379
48380   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48381   {
48382     try {
48383       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
48384     } catch (std::out_of_range& e) {
48385       {
48386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48387       };
48388     } catch (std::exception& e) {
48389       {
48390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48391       };
48392     } catch (Dali::DaliException e) {
48393       {
48394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48395       };
48396     } catch (...) {
48397       {
48398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48399       };
48400     }
48401   }
48402
48403 }
48404
48405
48406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
48407   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48408   int arg2 ;
48409   int arg3 ;
48410
48411   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48412   arg2 = (int)jarg2;
48413   arg3 = (int)jarg3;
48414   {
48415     try {
48416       try {
48417         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
48418       }
48419       catch(std::out_of_range &_e) {
48420         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48421         return ;
48422       }
48423       catch(std::invalid_argument &_e) {
48424         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
48425         return ;
48426       }
48427
48428     } catch (std::out_of_range& e) {
48429       {
48430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48431       };
48432     } catch (std::exception& e) {
48433       {
48434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48435       };
48436     } catch (Dali::DaliException e) {
48437       {
48438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48439       };
48440     } catch (...) {
48441       {
48442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48443       };
48444     }
48445   }
48446
48447 }
48448
48449
48450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
48451   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48452   int arg2 ;
48453   std::vector< Dali::TouchPoint > *arg3 = 0 ;
48454
48455   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48456   arg2 = (int)jarg2;
48457   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
48458   if (!arg3) {
48459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
48460     return ;
48461   }
48462   {
48463     try {
48464       try {
48465         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
48466       }
48467       catch(std::out_of_range &_e) {
48468         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48469         return ;
48470       }
48471
48472     } catch (std::out_of_range& e) {
48473       {
48474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48475       };
48476     } catch (std::exception& e) {
48477       {
48478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48479       };
48480     } catch (Dali::DaliException e) {
48481       {
48482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48483       };
48484     } catch (...) {
48485       {
48486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48487       };
48488     }
48489   }
48490
48491 }
48492
48493
48494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
48495   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48496
48497   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48498   {
48499     try {
48500       delete arg1;
48501     } catch (std::out_of_range& e) {
48502       {
48503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48504       };
48505     } catch (std::exception& e) {
48506       {
48507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48508       };
48509     } catch (Dali::DaliException e) {
48510       {
48511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48512       };
48513     } catch (...) {
48514       {
48515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48516       };
48517     }
48518   }
48519
48520 }
48521
48522
48523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
48524   void * jresult ;
48525   Dali::Rect< int > *result = 0 ;
48526
48527   {
48528     try {
48529       result = (Dali::Rect< int > *)new Dali::Rect< int >();
48530     } catch (std::out_of_range& e) {
48531       {
48532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48533       };
48534     } catch (std::exception& e) {
48535       {
48536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48537       };
48538     } catch (Dali::DaliException e) {
48539       {
48540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48541       };
48542     } catch (...) {
48543       {
48544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48545       };
48546     }
48547   }
48548
48549   jresult = (void *)result;
48550   return jresult;
48551 }
48552
48553
48554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
48555   void * jresult ;
48556   int arg1 ;
48557   int arg2 ;
48558   int arg3 ;
48559   int arg4 ;
48560   Dali::Rect< int > *result = 0 ;
48561
48562   arg1 = (int)jarg1;
48563   arg2 = (int)jarg2;
48564   arg3 = (int)jarg3;
48565   arg4 = (int)jarg4;
48566   {
48567     try {
48568       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
48569     } catch (std::out_of_range& e) {
48570       {
48571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48572       };
48573     } catch (std::exception& e) {
48574       {
48575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48576       };
48577     } catch (Dali::DaliException e) {
48578       {
48579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48580       };
48581     } catch (...) {
48582       {
48583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48584       };
48585     }
48586   }
48587
48588   jresult = (void *)result;
48589   return jresult;
48590 }
48591
48592
48593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
48594   void * jresult ;
48595   Dali::Rect< int > *arg1 = 0 ;
48596   Dali::Rect< int > *result = 0 ;
48597
48598   arg1 = (Dali::Rect< int > *)jarg1;
48599   if (!arg1) {
48600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
48601     return 0;
48602   }
48603   {
48604     try {
48605       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
48606     } catch (std::out_of_range& e) {
48607       {
48608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48609       };
48610     } catch (std::exception& e) {
48611       {
48612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48613       };
48614     } catch (Dali::DaliException e) {
48615       {
48616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48617       };
48618     } catch (...) {
48619       {
48620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48621       };
48622     }
48623   }
48624
48625   jresult = (void *)result;
48626   return jresult;
48627 }
48628
48629
48630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
48631   void * jresult ;
48632   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48633   Dali::Rect< int > *arg2 = 0 ;
48634   Dali::Rect< int > *result = 0 ;
48635
48636   arg1 = (Dali::Rect< int > *)jarg1;
48637   arg2 = (Dali::Rect< int > *)jarg2;
48638   if (!arg2) {
48639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
48640     return 0;
48641   }
48642   {
48643     try {
48644       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
48645     } catch (std::out_of_range& e) {
48646       {
48647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48648       };
48649     } catch (std::exception& e) {
48650       {
48651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48652       };
48653     } catch (Dali::DaliException e) {
48654       {
48655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48656       };
48657     } catch (...) {
48658       {
48659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48660       };
48661     }
48662   }
48663
48664   jresult = (void *)result;
48665   return jresult;
48666 }
48667
48668
48669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
48670   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48671   int arg2 ;
48672   int arg3 ;
48673   int arg4 ;
48674   int arg5 ;
48675
48676   arg1 = (Dali::Rect< int > *)jarg1;
48677   arg2 = (int)jarg2;
48678   arg3 = (int)jarg3;
48679   arg4 = (int)jarg4;
48680   arg5 = (int)jarg5;
48681   {
48682     try {
48683       (arg1)->Set(arg2,arg3,arg4,arg5);
48684     } catch (std::out_of_range& e) {
48685       {
48686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48687       };
48688     } catch (std::exception& e) {
48689       {
48690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48691       };
48692     } catch (Dali::DaliException e) {
48693       {
48694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48695       };
48696     } catch (...) {
48697       {
48698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48699       };
48700     }
48701   }
48702
48703 }
48704
48705
48706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
48707   unsigned int jresult ;
48708   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48709   bool result;
48710
48711   arg1 = (Dali::Rect< int > *)jarg1;
48712   {
48713     try {
48714       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
48715     } catch (std::out_of_range& e) {
48716       {
48717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48718       };
48719     } catch (std::exception& e) {
48720       {
48721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48722       };
48723     } catch (Dali::DaliException e) {
48724       {
48725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48726       };
48727     } catch (...) {
48728       {
48729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48730       };
48731     }
48732   }
48733
48734   jresult = result;
48735   return jresult;
48736 }
48737
48738
48739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
48740   int jresult ;
48741   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48742   int result;
48743
48744   arg1 = (Dali::Rect< int > *)jarg1;
48745   {
48746     try {
48747       result = (int)((Dali::Rect< int > const *)arg1)->Left();
48748     } catch (std::out_of_range& e) {
48749       {
48750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48751       };
48752     } catch (std::exception& e) {
48753       {
48754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48755       };
48756     } catch (Dali::DaliException e) {
48757       {
48758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48759       };
48760     } catch (...) {
48761       {
48762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48763       };
48764     }
48765   }
48766
48767   jresult = result;
48768   return jresult;
48769 }
48770
48771
48772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
48773   int jresult ;
48774   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48775   int result;
48776
48777   arg1 = (Dali::Rect< int > *)jarg1;
48778   {
48779     try {
48780       result = (int)((Dali::Rect< int > const *)arg1)->Right();
48781     } catch (std::out_of_range& e) {
48782       {
48783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48784       };
48785     } catch (std::exception& e) {
48786       {
48787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48788       };
48789     } catch (Dali::DaliException e) {
48790       {
48791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48792       };
48793     } catch (...) {
48794       {
48795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48796       };
48797     }
48798   }
48799
48800   jresult = result;
48801   return jresult;
48802 }
48803
48804
48805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
48806   int jresult ;
48807   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48808   int result;
48809
48810   arg1 = (Dali::Rect< int > *)jarg1;
48811   {
48812     try {
48813       result = (int)((Dali::Rect< int > const *)arg1)->Top();
48814     } catch (std::out_of_range& e) {
48815       {
48816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48817       };
48818     } catch (std::exception& e) {
48819       {
48820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48821       };
48822     } catch (Dali::DaliException e) {
48823       {
48824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48825       };
48826     } catch (...) {
48827       {
48828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48829       };
48830     }
48831   }
48832
48833   jresult = result;
48834   return jresult;
48835 }
48836
48837
48838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
48839   int jresult ;
48840   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48841   int result;
48842
48843   arg1 = (Dali::Rect< int > *)jarg1;
48844   {
48845     try {
48846       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
48847     } catch (std::out_of_range& e) {
48848       {
48849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48850       };
48851     } catch (std::exception& e) {
48852       {
48853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48854       };
48855     } catch (Dali::DaliException e) {
48856       {
48857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48858       };
48859     } catch (...) {
48860       {
48861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48862       };
48863     }
48864   }
48865
48866   jresult = result;
48867   return jresult;
48868 }
48869
48870
48871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
48872   int jresult ;
48873   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48874   int result;
48875
48876   arg1 = (Dali::Rect< int > *)jarg1;
48877   {
48878     try {
48879       result = (int)((Dali::Rect< int > const *)arg1)->Area();
48880     } catch (std::out_of_range& e) {
48881       {
48882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48883       };
48884     } catch (std::exception& e) {
48885       {
48886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48887       };
48888     } catch (Dali::DaliException e) {
48889       {
48890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48891       };
48892     } catch (...) {
48893       {
48894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48895       };
48896     }
48897   }
48898
48899   jresult = result;
48900   return jresult;
48901 }
48902
48903
48904 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
48905   unsigned int jresult ;
48906   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48907   Dali::Rect< int > *arg2 = 0 ;
48908   bool result;
48909
48910   arg1 = (Dali::Rect< int > *)jarg1;
48911   arg2 = (Dali::Rect< int > *)jarg2;
48912   if (!arg2) {
48913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
48914     return 0;
48915   }
48916   {
48917     try {
48918       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
48919     } catch (std::out_of_range& e) {
48920       {
48921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48922       };
48923     } catch (std::exception& e) {
48924       {
48925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48926       };
48927     } catch (Dali::DaliException e) {
48928       {
48929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48930       };
48931     } catch (...) {
48932       {
48933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48934       };
48935     }
48936   }
48937
48938   jresult = result;
48939   return jresult;
48940 }
48941
48942
48943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
48944   unsigned int jresult ;
48945   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48946   Dali::Rect< int > *arg2 = 0 ;
48947   bool result;
48948
48949   arg1 = (Dali::Rect< int > *)jarg1;
48950   arg2 = (Dali::Rect< int > *)jarg2;
48951   if (!arg2) {
48952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
48953     return 0;
48954   }
48955   {
48956     try {
48957       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
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 = result;
48978   return jresult;
48979 }
48980
48981
48982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
48983   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48984   int arg2 ;
48985
48986   arg1 = (Dali::Rect< int > *)jarg1;
48987   arg2 = (int)jarg2;
48988   if (arg1) (arg1)->x = arg2;
48989 }
48990
48991
48992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
48993   int jresult ;
48994   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48995   int result;
48996
48997   arg1 = (Dali::Rect< int > *)jarg1;
48998   result = (int) ((arg1)->x);
48999   jresult = result;
49000   return jresult;
49001 }
49002
49003
49004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
49005   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49006   int arg2 ;
49007
49008   arg1 = (Dali::Rect< int > *)jarg1;
49009   arg2 = (int)jarg2;
49010   if (arg1) (arg1)->left = arg2;
49011 }
49012
49013
49014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
49015   int jresult ;
49016   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49017   int result;
49018
49019   arg1 = (Dali::Rect< int > *)jarg1;
49020   result = (int) ((arg1)->left);
49021   jresult = result;
49022   return jresult;
49023 }
49024
49025
49026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
49027   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49028   int arg2 ;
49029
49030   arg1 = (Dali::Rect< int > *)jarg1;
49031   arg2 = (int)jarg2;
49032   if (arg1) (arg1)->y = arg2;
49033 }
49034
49035
49036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
49037   int jresult ;
49038   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49039   int result;
49040
49041   arg1 = (Dali::Rect< int > *)jarg1;
49042   result = (int) ((arg1)->y);
49043   jresult = result;
49044   return jresult;
49045 }
49046
49047
49048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
49049   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49050   int arg2 ;
49051
49052   arg1 = (Dali::Rect< int > *)jarg1;
49053   arg2 = (int)jarg2;
49054   if (arg1) (arg1)->right = arg2;
49055 }
49056
49057
49058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
49059   int jresult ;
49060   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49061   int result;
49062
49063   arg1 = (Dali::Rect< int > *)jarg1;
49064   result = (int) ((arg1)->right);
49065   jresult = result;
49066   return jresult;
49067 }
49068
49069
49070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
49071   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49072   int arg2 ;
49073
49074   arg1 = (Dali::Rect< int > *)jarg1;
49075   arg2 = (int)jarg2;
49076   if (arg1) (arg1)->width = arg2;
49077 }
49078
49079
49080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
49081   int jresult ;
49082   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49083   int result;
49084
49085   arg1 = (Dali::Rect< int > *)jarg1;
49086   result = (int) ((arg1)->width);
49087   jresult = result;
49088   return jresult;
49089 }
49090
49091
49092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
49093   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49094   int arg2 ;
49095
49096   arg1 = (Dali::Rect< int > *)jarg1;
49097   arg2 = (int)jarg2;
49098   if (arg1) (arg1)->bottom = arg2;
49099 }
49100
49101
49102 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
49103   int jresult ;
49104   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49105   int result;
49106
49107   arg1 = (Dali::Rect< int > *)jarg1;
49108   result = (int) ((arg1)->bottom);
49109   jresult = result;
49110   return jresult;
49111 }
49112
49113
49114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
49115   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49116   int arg2 ;
49117
49118   arg1 = (Dali::Rect< int > *)jarg1;
49119   arg2 = (int)jarg2;
49120   if (arg1) (arg1)->height = arg2;
49121 }
49122
49123
49124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
49125   int jresult ;
49126   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49127   int result;
49128
49129   arg1 = (Dali::Rect< int > *)jarg1;
49130   result = (int) ((arg1)->height);
49131   jresult = result;
49132   return jresult;
49133 }
49134
49135
49136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
49137   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49138   int arg2 ;
49139
49140   arg1 = (Dali::Rect< int > *)jarg1;
49141   arg2 = (int)jarg2;
49142   if (arg1) (arg1)->top = arg2;
49143 }
49144
49145
49146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
49147   int jresult ;
49148   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49149   int result;
49150
49151   arg1 = (Dali::Rect< int > *)jarg1;
49152   result = (int) ((arg1)->top);
49153   jresult = result;
49154   return jresult;
49155 }
49156
49157
49158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
49159   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49160
49161   arg1 = (Dali::Rect< int > *)jarg1;
49162   {
49163     try {
49164       delete arg1;
49165     } catch (std::out_of_range& e) {
49166       {
49167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49168       };
49169     } catch (std::exception& e) {
49170       {
49171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49172       };
49173     } catch (Dali::DaliException e) {
49174       {
49175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49176       };
49177     } catch (...) {
49178       {
49179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49180       };
49181     }
49182   }
49183
49184 }
49185
49186
49187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
49188   void * jresult ;
49189   Dali::Rect< float > *result = 0 ;
49190
49191   {
49192     try {
49193       result = (Dali::Rect< float > *)new Dali::Rect< float >();
49194     } catch (std::out_of_range& e) {
49195       {
49196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49197       };
49198     } catch (std::exception& e) {
49199       {
49200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49201       };
49202     } catch (Dali::DaliException e) {
49203       {
49204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49205       };
49206     } catch (...) {
49207       {
49208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49209       };
49210     }
49211   }
49212
49213   jresult = (void *)result;
49214   return jresult;
49215 }
49216
49217
49218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
49219   void * jresult ;
49220   float arg1 ;
49221   float arg2 ;
49222   float arg3 ;
49223   float arg4 ;
49224   Dali::Rect< float > *result = 0 ;
49225
49226   arg1 = (float)jarg1;
49227   arg2 = (float)jarg2;
49228   arg3 = (float)jarg4;
49229   arg4 = (float)jarg3;
49230   {
49231     try {
49232       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
49233     } catch (std::out_of_range& e) {
49234       {
49235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49236       };
49237     } catch (std::exception& e) {
49238       {
49239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49240       };
49241     } catch (Dali::DaliException e) {
49242       {
49243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49244       };
49245     } catch (...) {
49246       {
49247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49248       };
49249     }
49250   }
49251
49252   jresult = (void *)result;
49253   return jresult;
49254 }
49255
49256
49257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
49258   void * jresult ;
49259   Dali::Rect< float > *arg1 = 0 ;
49260   Dali::Rect< float > *result = 0 ;
49261
49262   arg1 = (Dali::Rect< float > *)jarg1;
49263   if (!arg1) {
49264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
49265     return 0;
49266   }
49267   {
49268     try {
49269       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
49270     } catch (std::out_of_range& e) {
49271       {
49272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49273       };
49274     } catch (std::exception& e) {
49275       {
49276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49277       };
49278     } catch (Dali::DaliException e) {
49279       {
49280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49281       };
49282     } catch (...) {
49283       {
49284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49285       };
49286     }
49287   }
49288
49289   jresult = (void *)result;
49290   return jresult;
49291 }
49292
49293
49294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
49295   void * jresult ;
49296   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49297   Dali::Rect< float > *arg2 = 0 ;
49298   Dali::Rect< float > *result = 0 ;
49299
49300   arg1 = (Dali::Rect< float > *)jarg1;
49301   arg2 = (Dali::Rect< float > *)jarg2;
49302   if (!arg2) {
49303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
49304     return 0;
49305   }
49306   {
49307     try {
49308       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
49309     } catch (std::out_of_range& e) {
49310       {
49311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49312       };
49313     } catch (std::exception& e) {
49314       {
49315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49316       };
49317     } catch (Dali::DaliException e) {
49318       {
49319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49320       };
49321     } catch (...) {
49322       {
49323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49324       };
49325     }
49326   }
49327
49328   jresult = (void *)result;
49329   return jresult;
49330 }
49331
49332
49333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
49334   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49335   float arg2 ;
49336   float arg3 ;
49337   float arg4 ;
49338   float arg5 ;
49339
49340   arg1 = (Dali::Rect< float > *)jarg1;
49341   arg2 = (float)jarg2;
49342   arg3 = (float)jarg3;
49343   arg4 = (float)jarg5;
49344   arg5 = (float)jarg4;
49345   {
49346     try {
49347       (arg1)->Set(arg2,arg3,arg4,arg5);
49348     } catch (std::out_of_range& e) {
49349       {
49350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49351       };
49352     } catch (std::exception& e) {
49353       {
49354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49355       };
49356     } catch (Dali::DaliException e) {
49357       {
49358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49359       };
49360     } catch (...) {
49361       {
49362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49363       };
49364     }
49365   }
49366
49367 }
49368
49369
49370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
49371   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49372   float arg2 ;
49373
49374   arg1 = (Dali::Rect< float > *)jarg1;
49375   arg2 = (float)jarg2;
49376   if (arg1) (arg1)->left = arg2;
49377 }
49378
49379
49380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
49381   float jresult ;
49382   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49383   float result;
49384
49385   arg1 = (Dali::Rect< float > *)jarg1;
49386   result = (float) ((arg1)->left);
49387   jresult = result;
49388   return jresult;
49389 }
49390
49391
49392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
49393   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49394   float arg2 ;
49395
49396   arg1 = (Dali::Rect< float > *)jarg1;
49397   arg2 = (float)jarg2;
49398   if (arg1) (arg1)->left = arg2;
49399 }
49400
49401
49402 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
49403   float jresult ;
49404   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49405   float result;
49406
49407   arg1 = (Dali::Rect< float > *)jarg1;
49408   result = (float) ((arg1)->left);
49409   jresult = result;
49410   return jresult;
49411 }
49412
49413
49414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
49415   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49416   float arg2 ;
49417
49418   arg1 = (Dali::Rect< float > *)jarg1;
49419   arg2 = (float)jarg2;
49420   if (arg1) (arg1)->right = arg2;
49421 }
49422
49423
49424 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
49425   float jresult ;
49426   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49427   float result;
49428
49429   arg1 = (Dali::Rect< float > *)jarg1;
49430   result = (float) ((arg1)->right);
49431   jresult = result;
49432   return jresult;
49433 }
49434
49435
49436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
49437   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49438   float arg2 ;
49439
49440   arg1 = (Dali::Rect< float > *)jarg1;
49441   arg2 = (float)jarg2;
49442   if (arg1) (arg1)->right = arg2;
49443 }
49444
49445
49446 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
49447   float jresult ;
49448   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49449   float result;
49450
49451   arg1 = (Dali::Rect< float > *)jarg1;
49452   result = (float) ((arg1)->right);
49453   jresult = result;
49454   return jresult;
49455 }
49456
49457
49458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
49459   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49460   float arg2 ;
49461
49462   arg1 = (Dali::Rect< float > *)jarg1;
49463   arg2 = (float)jarg2;
49464   if (arg1) (arg1)->bottom = arg2;
49465 }
49466
49467
49468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
49469   float jresult ;
49470   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49471   float result;
49472
49473   arg1 = (Dali::Rect< float > *)jarg1;
49474   result = (float) ((arg1)->bottom);
49475   jresult = result;
49476   return jresult;
49477 }
49478
49479
49480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
49481   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49482   float arg2 ;
49483
49484   arg1 = (Dali::Rect< float > *)jarg1;
49485   arg2 = (float)jarg2;
49486   if (arg1) (arg1)->top = arg2;
49487 }
49488
49489
49490 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
49491   float jresult ;
49492   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49493   float result;
49494
49495   arg1 = (Dali::Rect< float > *)jarg1;
49496   result = (float) ((arg1)->top);
49497   jresult = result;
49498   return jresult;
49499 }
49500
49501
49502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
49503   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49504
49505   arg1 = (Dali::Rect< float > *)jarg1;
49506   {
49507     try {
49508       delete arg1;
49509     } catch (std::out_of_range& e) {
49510       {
49511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49512       };
49513     } catch (std::exception& e) {
49514       {
49515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49516       };
49517     } catch (Dali::DaliException e) {
49518       {
49519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49520       };
49521     } catch (...) {
49522       {
49523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49524       };
49525     }
49526   }
49527
49528 }
49529
49530
49531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
49532   int jresult ;
49533   int result;
49534
49535   result = (int)Dali::Vector< int >::BaseType;
49536   jresult = (int)result;
49537   return jresult;
49538 }
49539
49540
49541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
49542   void * jresult ;
49543   Dali::Vector< int > *result = 0 ;
49544
49545   {
49546     try {
49547       result = (Dali::Vector< int > *)new Dali::Vector< int >();
49548     } catch (std::out_of_range& e) {
49549       {
49550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49551       };
49552     } catch (std::exception& e) {
49553       {
49554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49555       };
49556     } catch (Dali::DaliException e) {
49557       {
49558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49559       };
49560     } catch (...) {
49561       {
49562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49563       };
49564     }
49565   }
49566
49567   jresult = (void *)result;
49568   return jresult;
49569 }
49570
49571
49572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
49573   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49574
49575   arg1 = (Dali::Vector< int > *)jarg1;
49576   {
49577     try {
49578       delete arg1;
49579     } catch (std::out_of_range& e) {
49580       {
49581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49582       };
49583     } catch (std::exception& e) {
49584       {
49585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49586       };
49587     } catch (Dali::DaliException e) {
49588       {
49589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49590       };
49591     } catch (...) {
49592       {
49593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49594       };
49595     }
49596   }
49597
49598 }
49599
49600
49601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
49602   void * jresult ;
49603   Dali::Vector< int > *arg1 = 0 ;
49604   Dali::Vector< int > *result = 0 ;
49605
49606   arg1 = (Dali::Vector< int > *)jarg1;
49607   if (!arg1) {
49608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
49609     return 0;
49610   }
49611   {
49612     try {
49613       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
49614     } catch (std::out_of_range& e) {
49615       {
49616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49617       };
49618     } catch (std::exception& e) {
49619       {
49620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49621       };
49622     } catch (Dali::DaliException e) {
49623       {
49624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49625       };
49626     } catch (...) {
49627       {
49628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49629       };
49630     }
49631   }
49632
49633   jresult = (void *)result;
49634   return jresult;
49635 }
49636
49637
49638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
49639   void * jresult ;
49640   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49641   Dali::Vector< int > *arg2 = 0 ;
49642   Dali::Vector< int > *result = 0 ;
49643
49644   arg1 = (Dali::Vector< int > *)jarg1;
49645   arg2 = (Dali::Vector< int > *)jarg2;
49646   if (!arg2) {
49647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
49648     return 0;
49649   }
49650   {
49651     try {
49652       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
49653     } catch (std::out_of_range& e) {
49654       {
49655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49656       };
49657     } catch (std::exception& e) {
49658       {
49659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49660       };
49661     } catch (Dali::DaliException e) {
49662       {
49663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49664       };
49665     } catch (...) {
49666       {
49667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49668       };
49669     }
49670   }
49671
49672   jresult = (void *)result;
49673   return jresult;
49674 }
49675
49676
49677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
49678   void * jresult ;
49679   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49680   Dali::Vector< int >::Iterator result;
49681
49682   arg1 = (Dali::Vector< int > *)jarg1;
49683   {
49684     try {
49685       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
49686     } catch (std::out_of_range& e) {
49687       {
49688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49689       };
49690     } catch (std::exception& e) {
49691       {
49692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49693       };
49694     } catch (Dali::DaliException e) {
49695       {
49696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49697       };
49698     } catch (...) {
49699       {
49700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49701       };
49702     }
49703   }
49704
49705   jresult = (void *)result;
49706   return jresult;
49707 }
49708
49709
49710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
49711   void * jresult ;
49712   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49713   Dali::Vector< int >::Iterator result;
49714
49715   arg1 = (Dali::Vector< int > *)jarg1;
49716   {
49717     try {
49718       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
49719     } catch (std::out_of_range& e) {
49720       {
49721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49722       };
49723     } catch (std::exception& e) {
49724       {
49725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49726       };
49727     } catch (Dali::DaliException e) {
49728       {
49729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49730       };
49731     } catch (...) {
49732       {
49733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49734       };
49735     }
49736   }
49737
49738   jresult = (void *)result;
49739   return jresult;
49740 }
49741
49742
49743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49744   void * jresult ;
49745   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49746   Dali::Vector< int >::SizeType arg2 ;
49747   Dali::Vector< int >::ItemType *result = 0 ;
49748
49749   arg1 = (Dali::Vector< int > *)jarg1;
49750   arg2 = (Dali::Vector< int >::SizeType)jarg2;
49751   {
49752     try {
49753       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
49754     } catch (std::out_of_range& e) {
49755       {
49756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49757       };
49758     } catch (std::exception& e) {
49759       {
49760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49761       };
49762     } catch (Dali::DaliException e) {
49763       {
49764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49765       };
49766     } catch (...) {
49767       {
49768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49769       };
49770     }
49771   }
49772
49773   jresult = (void *)result;
49774   return jresult;
49775 }
49776
49777
49778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
49779   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49780   Dali::Vector< int >::ItemType *arg2 = 0 ;
49781   Dali::Vector< int >::ItemType temp2 ;
49782
49783   arg1 = (Dali::Vector< int > *)jarg1;
49784   temp2 = (Dali::Vector< int >::ItemType)jarg2;
49785   arg2 = &temp2;
49786   {
49787     try {
49788       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
49789     } catch (std::out_of_range& e) {
49790       {
49791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49792       };
49793     } catch (std::exception& e) {
49794       {
49795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49796       };
49797     } catch (Dali::DaliException e) {
49798       {
49799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49800       };
49801     } catch (...) {
49802       {
49803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49804       };
49805     }
49806   }
49807
49808 }
49809
49810
49811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
49812   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49813   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
49814   Dali::Vector< int >::ItemType *arg3 = 0 ;
49815   Dali::Vector< int >::ItemType temp3 ;
49816
49817   arg1 = (Dali::Vector< int > *)jarg1;
49818   arg2 = (Dali::Vector< int >::Iterator)jarg2;
49819   temp3 = (Dali::Vector< int >::ItemType)jarg3;
49820   arg3 = &temp3;
49821   {
49822     try {
49823       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
49824     } catch (std::out_of_range& e) {
49825       {
49826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49827       };
49828     } catch (std::exception& e) {
49829       {
49830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49831       };
49832     } catch (Dali::DaliException e) {
49833       {
49834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49835       };
49836     } catch (...) {
49837       {
49838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49839       };
49840     }
49841   }
49842
49843 }
49844
49845
49846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49847   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49848   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
49849   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
49850   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
49851
49852   arg1 = (Dali::Vector< int > *)jarg1;
49853   arg2 = (Dali::Vector< int >::Iterator)jarg2;
49854   arg3 = (Dali::Vector< int >::Iterator)jarg3;
49855   arg4 = (Dali::Vector< int >::Iterator)jarg4;
49856   {
49857     try {
49858       (arg1)->Insert(arg2,arg3,arg4);
49859     } catch (std::out_of_range& e) {
49860       {
49861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49862       };
49863     } catch (std::exception& e) {
49864       {
49865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49866       };
49867     } catch (Dali::DaliException e) {
49868       {
49869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49870       };
49871     } catch (...) {
49872       {
49873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49874       };
49875     }
49876   }
49877
49878 }
49879
49880
49881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
49882   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49883   Dali::Vector< int >::SizeType arg2 ;
49884
49885   arg1 = (Dali::Vector< int > *)jarg1;
49886   arg2 = (Dali::Vector< int >::SizeType)jarg2;
49887   {
49888     try {
49889       (arg1)->Reserve(arg2);
49890     } catch (std::out_of_range& e) {
49891       {
49892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49893       };
49894     } catch (std::exception& e) {
49895       {
49896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49897       };
49898     } catch (Dali::DaliException e) {
49899       {
49900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49901       };
49902     } catch (...) {
49903       {
49904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49905       };
49906     }
49907   }
49908
49909 }
49910
49911
49912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49913   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49914   Dali::Vector< int >::SizeType arg2 ;
49915
49916   arg1 = (Dali::Vector< int > *)jarg1;
49917   arg2 = (Dali::Vector< int >::SizeType)jarg2;
49918   {
49919     try {
49920       (arg1)->Resize(arg2);
49921     } catch (std::out_of_range& e) {
49922       {
49923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49924       };
49925     } catch (std::exception& e) {
49926       {
49927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49928       };
49929     } catch (Dali::DaliException e) {
49930       {
49931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49932       };
49933     } catch (...) {
49934       {
49935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49936       };
49937     }
49938   }
49939
49940 }
49941
49942
49943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
49944   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49945   Dali::Vector< int >::SizeType arg2 ;
49946   Dali::Vector< int >::ItemType *arg3 = 0 ;
49947   Dali::Vector< int >::ItemType temp3 ;
49948
49949   arg1 = (Dali::Vector< int > *)jarg1;
49950   arg2 = (Dali::Vector< int >::SizeType)jarg2;
49951   temp3 = (Dali::Vector< int >::ItemType)jarg3;
49952   arg3 = &temp3;
49953   {
49954     try {
49955       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
49956     } catch (std::out_of_range& e) {
49957       {
49958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49959       };
49960     } catch (std::exception& e) {
49961       {
49962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49963       };
49964     } catch (Dali::DaliException e) {
49965       {
49966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49967       };
49968     } catch (...) {
49969       {
49970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49971       };
49972     }
49973   }
49974
49975 }
49976
49977
49978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
49979   void * jresult ;
49980   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49981   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
49982   Dali::Vector< int >::Iterator result;
49983
49984   arg1 = (Dali::Vector< int > *)jarg1;
49985   arg2 = (Dali::Vector< int >::Iterator)jarg2;
49986   {
49987     try {
49988       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
49989     } catch (std::out_of_range& e) {
49990       {
49991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49992       };
49993     } catch (std::exception& e) {
49994       {
49995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49996       };
49997     } catch (Dali::DaliException e) {
49998       {
49999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50000       };
50001     } catch (...) {
50002       {
50003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50004       };
50005     }
50006   }
50007
50008   jresult = (void *)result;
50009   return jresult;
50010 }
50011
50012
50013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50014   void * jresult ;
50015   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50016   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
50017   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
50018   Dali::Vector< int >::Iterator result;
50019
50020   arg1 = (Dali::Vector< int > *)jarg1;
50021   arg2 = (Dali::Vector< int >::Iterator)jarg2;
50022   arg3 = (Dali::Vector< int >::Iterator)jarg3;
50023   {
50024     try {
50025       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
50026     } catch (std::out_of_range& e) {
50027       {
50028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50029       };
50030     } catch (std::exception& e) {
50031       {
50032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50033       };
50034     } catch (Dali::DaliException e) {
50035       {
50036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50037       };
50038     } catch (...) {
50039       {
50040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50041       };
50042     }
50043   }
50044
50045   jresult = (void *)result;
50046   return jresult;
50047 }
50048
50049
50050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
50051   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50052   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
50053
50054   arg1 = (Dali::Vector< int > *)jarg1;
50055   arg2 = (Dali::Vector< int >::Iterator)jarg2;
50056   {
50057     try {
50058       (arg1)->Remove(arg2);
50059     } catch (std::out_of_range& e) {
50060       {
50061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50062       };
50063     } catch (std::exception& e) {
50064       {
50065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50066       };
50067     } catch (Dali::DaliException e) {
50068       {
50069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50070       };
50071     } catch (...) {
50072       {
50073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50074       };
50075     }
50076   }
50077
50078 }
50079
50080
50081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
50082   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50083   Dali::Vector< int > *arg2 = 0 ;
50084
50085   arg1 = (Dali::Vector< int > *)jarg1;
50086   arg2 = (Dali::Vector< int > *)jarg2;
50087   if (!arg2) {
50088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
50089     return ;
50090   }
50091   {
50092     try {
50093       (arg1)->Swap(*arg2);
50094     } catch (std::out_of_range& e) {
50095       {
50096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50097       };
50098     } catch (std::exception& e) {
50099       {
50100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50101       };
50102     } catch (Dali::DaliException e) {
50103       {
50104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50105       };
50106     } catch (...) {
50107       {
50108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50109       };
50110     }
50111   }
50112
50113 }
50114
50115
50116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
50117   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50118
50119   arg1 = (Dali::Vector< int > *)jarg1;
50120   {
50121     try {
50122       (arg1)->Clear();
50123     } catch (std::out_of_range& e) {
50124       {
50125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50126       };
50127     } catch (std::exception& e) {
50128       {
50129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50130       };
50131     } catch (Dali::DaliException e) {
50132       {
50133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50134       };
50135     } catch (...) {
50136       {
50137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50138       };
50139     }
50140   }
50141
50142 }
50143
50144
50145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
50146   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50147
50148   arg1 = (Dali::Vector< int > *)jarg1;
50149   {
50150     try {
50151       (arg1)->Release();
50152     } catch (std::out_of_range& e) {
50153       {
50154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50155       };
50156     } catch (std::exception& e) {
50157       {
50158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50159       };
50160     } catch (Dali::DaliException e) {
50161       {
50162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50163       };
50164     } catch (...) {
50165       {
50166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50167       };
50168     }
50169   }
50170
50171 }
50172
50173
50174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
50175   int jresult ;
50176   int result;
50177
50178   result = (int)Dali::Vector< float >::BaseType;
50179   jresult = (int)result;
50180   return jresult;
50181 }
50182
50183
50184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
50185   void * jresult ;
50186   Dali::Vector< float > *result = 0 ;
50187
50188   {
50189     try {
50190       result = (Dali::Vector< float > *)new Dali::Vector< float >();
50191     } catch (std::out_of_range& e) {
50192       {
50193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50194       };
50195     } catch (std::exception& e) {
50196       {
50197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50198       };
50199     } catch (Dali::DaliException e) {
50200       {
50201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50202       };
50203     } catch (...) {
50204       {
50205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50206       };
50207     }
50208   }
50209
50210   jresult = (void *)result;
50211   return jresult;
50212 }
50213
50214
50215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
50216   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50217
50218   arg1 = (Dali::Vector< float > *)jarg1;
50219   {
50220     try {
50221       delete arg1;
50222     } catch (std::out_of_range& e) {
50223       {
50224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50225       };
50226     } catch (std::exception& e) {
50227       {
50228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50229       };
50230     } catch (Dali::DaliException e) {
50231       {
50232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50233       };
50234     } catch (...) {
50235       {
50236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50237       };
50238     }
50239   }
50240
50241 }
50242
50243
50244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
50245   void * jresult ;
50246   Dali::Vector< float > *arg1 = 0 ;
50247   Dali::Vector< float > *result = 0 ;
50248
50249   arg1 = (Dali::Vector< float > *)jarg1;
50250   if (!arg1) {
50251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
50252     return 0;
50253   }
50254   {
50255     try {
50256       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
50257     } catch (std::out_of_range& e) {
50258       {
50259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50260       };
50261     } catch (std::exception& e) {
50262       {
50263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50264       };
50265     } catch (Dali::DaliException e) {
50266       {
50267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50268       };
50269     } catch (...) {
50270       {
50271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50272       };
50273     }
50274   }
50275
50276   jresult = (void *)result;
50277   return jresult;
50278 }
50279
50280
50281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
50282   void * jresult ;
50283   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50284   Dali::Vector< float > *arg2 = 0 ;
50285   Dali::Vector< float > *result = 0 ;
50286
50287   arg1 = (Dali::Vector< float > *)jarg1;
50288   arg2 = (Dali::Vector< float > *)jarg2;
50289   if (!arg2) {
50290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
50291     return 0;
50292   }
50293   {
50294     try {
50295       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
50296     } catch (std::out_of_range& e) {
50297       {
50298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50299       };
50300     } catch (std::exception& e) {
50301       {
50302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50303       };
50304     } catch (Dali::DaliException e) {
50305       {
50306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50307       };
50308     } catch (...) {
50309       {
50310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50311       };
50312     }
50313   }
50314
50315   jresult = (void *)result;
50316   return jresult;
50317 }
50318
50319
50320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
50321   void * jresult ;
50322   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50323   Dali::Vector< float >::Iterator result;
50324
50325   arg1 = (Dali::Vector< float > *)jarg1;
50326   {
50327     try {
50328       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
50329     } catch (std::out_of_range& e) {
50330       {
50331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50332       };
50333     } catch (std::exception& e) {
50334       {
50335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50336       };
50337     } catch (Dali::DaliException e) {
50338       {
50339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50340       };
50341     } catch (...) {
50342       {
50343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50344       };
50345     }
50346   }
50347
50348   jresult = (void *)result;
50349   return jresult;
50350 }
50351
50352
50353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
50354   void * jresult ;
50355   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50356   Dali::Vector< float >::Iterator result;
50357
50358   arg1 = (Dali::Vector< float > *)jarg1;
50359   {
50360     try {
50361       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
50362     } catch (std::out_of_range& e) {
50363       {
50364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50365       };
50366     } catch (std::exception& e) {
50367       {
50368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50369       };
50370     } catch (Dali::DaliException e) {
50371       {
50372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50373       };
50374     } catch (...) {
50375       {
50376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50377       };
50378     }
50379   }
50380
50381   jresult = (void *)result;
50382   return jresult;
50383 }
50384
50385
50386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50387   void * jresult ;
50388   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50389   Dali::Vector< float >::SizeType arg2 ;
50390   Dali::Vector< float >::ItemType *result = 0 ;
50391
50392   arg1 = (Dali::Vector< float > *)jarg1;
50393   arg2 = (Dali::Vector< float >::SizeType)jarg2;
50394   {
50395     try {
50396       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
50397     } catch (std::out_of_range& e) {
50398       {
50399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50400       };
50401     } catch (std::exception& e) {
50402       {
50403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50404       };
50405     } catch (Dali::DaliException e) {
50406       {
50407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50408       };
50409     } catch (...) {
50410       {
50411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50412       };
50413     }
50414   }
50415
50416   jresult = (void *)result;
50417   return jresult;
50418 }
50419
50420
50421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
50422   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50423   Dali::Vector< float >::ItemType *arg2 = 0 ;
50424   Dali::Vector< float >::ItemType temp2 ;
50425
50426   arg1 = (Dali::Vector< float > *)jarg1;
50427   temp2 = (Dali::Vector< float >::ItemType)jarg2;
50428   arg2 = &temp2;
50429   {
50430     try {
50431       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
50432     } catch (std::out_of_range& e) {
50433       {
50434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50435       };
50436     } catch (std::exception& e) {
50437       {
50438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50439       };
50440     } catch (Dali::DaliException e) {
50441       {
50442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50443       };
50444     } catch (...) {
50445       {
50446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50447       };
50448     }
50449   }
50450
50451 }
50452
50453
50454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
50455   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50456   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
50457   Dali::Vector< float >::ItemType *arg3 = 0 ;
50458   Dali::Vector< float >::ItemType temp3 ;
50459
50460   arg1 = (Dali::Vector< float > *)jarg1;
50461   arg2 = (Dali::Vector< float >::Iterator)jarg2;
50462   temp3 = (Dali::Vector< float >::ItemType)jarg3;
50463   arg3 = &temp3;
50464   {
50465     try {
50466       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
50467     } catch (std::out_of_range& e) {
50468       {
50469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50470       };
50471     } catch (std::exception& e) {
50472       {
50473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50474       };
50475     } catch (Dali::DaliException e) {
50476       {
50477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50478       };
50479     } catch (...) {
50480       {
50481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50482       };
50483     }
50484   }
50485
50486 }
50487
50488
50489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
50490   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50491   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
50492   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
50493   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
50494
50495   arg1 = (Dali::Vector< float > *)jarg1;
50496   arg2 = (Dali::Vector< float >::Iterator)jarg2;
50497   arg3 = (Dali::Vector< float >::Iterator)jarg3;
50498   arg4 = (Dali::Vector< float >::Iterator)jarg4;
50499   {
50500     try {
50501       (arg1)->Insert(arg2,arg3,arg4);
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_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
50525   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50526   Dali::Vector< float >::SizeType arg2 ;
50527
50528   arg1 = (Dali::Vector< float > *)jarg1;
50529   arg2 = (Dali::Vector< float >::SizeType)jarg2;
50530   {
50531     try {
50532       (arg1)->Reserve(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 //// ========================= end of part 2 =============================
50555
50556 //// ========================== start part 3 ===============================
50557
50558
50559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50560   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50561   Dali::Vector< float >::SizeType arg2 ;
50562
50563   arg1 = (Dali::Vector< float > *)jarg1;
50564   arg2 = (Dali::Vector< float >::SizeType)jarg2;
50565   {
50566     try {
50567       (arg1)->Resize(arg2);
50568     } catch (std::out_of_range& e) {
50569       {
50570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50571       };
50572     } catch (std::exception& e) {
50573       {
50574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50575       };
50576     } catch (Dali::DaliException e) {
50577       {
50578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50579       };
50580     } catch (...) {
50581       {
50582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50583       };
50584     }
50585   }
50586
50587 }
50588
50589
50590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
50591   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50592   Dali::Vector< float >::SizeType arg2 ;
50593   Dali::Vector< float >::ItemType *arg3 = 0 ;
50594   Dali::Vector< float >::ItemType temp3 ;
50595
50596   arg1 = (Dali::Vector< float > *)jarg1;
50597   arg2 = (Dali::Vector< float >::SizeType)jarg2;
50598   temp3 = (Dali::Vector< float >::ItemType)jarg3;
50599   arg3 = &temp3;
50600   {
50601     try {
50602       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
50603     } catch (std::out_of_range& e) {
50604       {
50605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50606       };
50607     } catch (std::exception& e) {
50608       {
50609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50610       };
50611     } catch (Dali::DaliException e) {
50612       {
50613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50614       };
50615     } catch (...) {
50616       {
50617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50618       };
50619     }
50620   }
50621
50622 }
50623
50624
50625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
50626   void * jresult ;
50627   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50628   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
50629   Dali::Vector< float >::Iterator result;
50630
50631   arg1 = (Dali::Vector< float > *)jarg1;
50632   arg2 = (Dali::Vector< float >::Iterator)jarg2;
50633   {
50634     try {
50635       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
50636     } catch (std::out_of_range& e) {
50637       {
50638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50639       };
50640     } catch (std::exception& e) {
50641       {
50642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50643       };
50644     } catch (Dali::DaliException e) {
50645       {
50646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50647       };
50648     } catch (...) {
50649       {
50650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50651       };
50652     }
50653   }
50654
50655   jresult = (void *)result;
50656   return jresult;
50657 }
50658
50659
50660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50661   void * jresult ;
50662   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50663   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
50664   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
50665   Dali::Vector< float >::Iterator result;
50666
50667   arg1 = (Dali::Vector< float > *)jarg1;
50668   arg2 = (Dali::Vector< float >::Iterator)jarg2;
50669   arg3 = (Dali::Vector< float >::Iterator)jarg3;
50670   {
50671     try {
50672       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
50673     } catch (std::out_of_range& e) {
50674       {
50675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50676       };
50677     } catch (std::exception& e) {
50678       {
50679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50680       };
50681     } catch (Dali::DaliException e) {
50682       {
50683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50684       };
50685     } catch (...) {
50686       {
50687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50688       };
50689     }
50690   }
50691
50692   jresult = (void *)result;
50693   return jresult;
50694 }
50695
50696
50697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
50698   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50699   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
50700
50701   arg1 = (Dali::Vector< float > *)jarg1;
50702   arg2 = (Dali::Vector< float >::Iterator)jarg2;
50703   {
50704     try {
50705       (arg1)->Remove(arg2);
50706     } catch (std::out_of_range& e) {
50707       {
50708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50709       };
50710     } catch (std::exception& e) {
50711       {
50712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50713       };
50714     } catch (Dali::DaliException e) {
50715       {
50716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50717       };
50718     } catch (...) {
50719       {
50720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50721       };
50722     }
50723   }
50724
50725 }
50726
50727
50728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
50729   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50730   Dali::Vector< float > *arg2 = 0 ;
50731
50732   arg1 = (Dali::Vector< float > *)jarg1;
50733   arg2 = (Dali::Vector< float > *)jarg2;
50734   if (!arg2) {
50735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
50736     return ;
50737   }
50738   {
50739     try {
50740       (arg1)->Swap(*arg2);
50741     } catch (std::out_of_range& e) {
50742       {
50743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50744       };
50745     } catch (std::exception& e) {
50746       {
50747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50748       };
50749     } catch (Dali::DaliException e) {
50750       {
50751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50752       };
50753     } catch (...) {
50754       {
50755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50756       };
50757     }
50758   }
50759
50760 }
50761
50762
50763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
50764   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50765
50766   arg1 = (Dali::Vector< float > *)jarg1;
50767   {
50768     try {
50769       (arg1)->Clear();
50770     } catch (std::out_of_range& e) {
50771       {
50772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50773       };
50774     } catch (std::exception& e) {
50775       {
50776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50777       };
50778     } catch (Dali::DaliException e) {
50779       {
50780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50781       };
50782     } catch (...) {
50783       {
50784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50785       };
50786     }
50787   }
50788
50789 }
50790
50791
50792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
50793   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50794
50795   arg1 = (Dali::Vector< float > *)jarg1;
50796   {
50797     try {
50798       (arg1)->Release();
50799     } catch (std::out_of_range& e) {
50800       {
50801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50802       };
50803     } catch (std::exception& e) {
50804       {
50805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50806       };
50807     } catch (Dali::DaliException e) {
50808       {
50809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50810       };
50811     } catch (...) {
50812       {
50813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50814       };
50815     }
50816   }
50817
50818 }
50819
50820
50821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
50822   int jresult ;
50823   int result;
50824
50825   result = (int)Dali::Vector< unsigned char >::BaseType;
50826   jresult = (int)result;
50827   return jresult;
50828 }
50829
50830
50831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
50832   void * jresult ;
50833   Dali::Vector< unsigned char > *result = 0 ;
50834
50835   {
50836     try {
50837       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
50838     } catch (std::out_of_range& e) {
50839       {
50840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50841       };
50842     } catch (std::exception& e) {
50843       {
50844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50845       };
50846     } catch (Dali::DaliException e) {
50847       {
50848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50849       };
50850     } catch (...) {
50851       {
50852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50853       };
50854     }
50855   }
50856
50857   jresult = (void *)result;
50858   return jresult;
50859 }
50860
50861
50862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
50863   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50864
50865   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50866   {
50867     try {
50868       delete arg1;
50869     } catch (std::out_of_range& e) {
50870       {
50871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50872       };
50873     } catch (std::exception& e) {
50874       {
50875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50876       };
50877     } catch (Dali::DaliException e) {
50878       {
50879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50880       };
50881     } catch (...) {
50882       {
50883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50884       };
50885     }
50886   }
50887
50888 }
50889
50890
50891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
50892   void * jresult ;
50893   Dali::Vector< unsigned char > *arg1 = 0 ;
50894   Dali::Vector< unsigned char > *result = 0 ;
50895
50896   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50897   if (!arg1) {
50898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
50899     return 0;
50900   }
50901   {
50902     try {
50903       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
50904     } catch (std::out_of_range& e) {
50905       {
50906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50907       };
50908     } catch (std::exception& e) {
50909       {
50910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50911       };
50912     } catch (Dali::DaliException e) {
50913       {
50914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50915       };
50916     } catch (...) {
50917       {
50918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50919       };
50920     }
50921   }
50922
50923   jresult = (void *)result;
50924   return jresult;
50925 }
50926
50927
50928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
50929   void * jresult ;
50930   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50931   Dali::Vector< unsigned char > *arg2 = 0 ;
50932   Dali::Vector< unsigned char > *result = 0 ;
50933
50934   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50935   arg2 = (Dali::Vector< unsigned char > *)jarg2;
50936   if (!arg2) {
50937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
50938     return 0;
50939   }
50940   {
50941     try {
50942       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
50943     } catch (std::out_of_range& e) {
50944       {
50945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50946       };
50947     } catch (std::exception& e) {
50948       {
50949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50950       };
50951     } catch (Dali::DaliException e) {
50952       {
50953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50954       };
50955     } catch (...) {
50956       {
50957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50958       };
50959     }
50960   }
50961
50962   jresult = (void *)result;
50963   return jresult;
50964 }
50965
50966
50967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
50968   void * jresult ;
50969   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
50970   Dali::Vector< unsigned char >::Iterator result;
50971
50972   arg1 = (Dali::Vector< unsigned char > *)jarg1;
50973   {
50974     try {
50975       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
50976     } catch (std::out_of_range& e) {
50977       {
50978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50979       };
50980     } catch (std::exception& e) {
50981       {
50982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50983       };
50984     } catch (Dali::DaliException e) {
50985       {
50986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50987       };
50988     } catch (...) {
50989       {
50990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50991       };
50992     }
50993   }
50994
50995   jresult = (void *)result;
50996   return jresult;
50997 }
50998
50999
51000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
51001   void * jresult ;
51002   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51003   Dali::Vector< unsigned char >::Iterator result;
51004
51005   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51006   {
51007     try {
51008       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
51009     } catch (std::out_of_range& e) {
51010       {
51011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51012       };
51013     } catch (std::exception& e) {
51014       {
51015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51016       };
51017     } catch (Dali::DaliException e) {
51018       {
51019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51020       };
51021     } catch (...) {
51022       {
51023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51024       };
51025     }
51026   }
51027
51028   jresult = (void *)result;
51029   return jresult;
51030 }
51031
51032
51033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51034   void * jresult ;
51035   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51036   Dali::Vector< unsigned char >::SizeType arg2 ;
51037   Dali::Vector< unsigned char >::ItemType *result = 0 ;
51038
51039   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51040   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
51041   {
51042     try {
51043       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
51044     } catch (std::out_of_range& e) {
51045       {
51046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51047       };
51048     } catch (std::exception& e) {
51049       {
51050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51051       };
51052     } catch (Dali::DaliException e) {
51053       {
51054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51055       };
51056     } catch (...) {
51057       {
51058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51059       };
51060     }
51061   }
51062
51063   jresult = (void *)result;
51064   return jresult;
51065 }
51066
51067
51068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
51069   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51070   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
51071   Dali::Vector< unsigned char >::ItemType temp2 ;
51072
51073   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51074   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
51075   arg2 = &temp2;
51076   {
51077     try {
51078       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
51079     } catch (std::out_of_range& e) {
51080       {
51081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51082       };
51083     } catch (std::exception& e) {
51084       {
51085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51086       };
51087     } catch (Dali::DaliException e) {
51088       {
51089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51090       };
51091     } catch (...) {
51092       {
51093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51094       };
51095     }
51096   }
51097
51098 }
51099
51100
51101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
51102   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51103   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51104   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
51105   Dali::Vector< unsigned char >::ItemType temp3 ;
51106
51107   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51108   arg2 = jarg2;
51109   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
51110   arg3 = &temp3;
51111   {
51112     try {
51113       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
51114     } catch (std::out_of_range& e) {
51115       {
51116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51117       };
51118     } catch (std::exception& e) {
51119       {
51120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51121       };
51122     } catch (Dali::DaliException e) {
51123       {
51124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51125       };
51126     } catch (...) {
51127       {
51128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51129       };
51130     }
51131   }
51132
51133
51134
51135 }
51136
51137
51138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
51139   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51140   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51141   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51142   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51143
51144   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51145   arg2 = jarg2;
51146   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
51147   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
51148   {
51149     try {
51150       (arg1)->Insert(arg2,arg3,arg4);
51151     } catch (std::out_of_range& e) {
51152       {
51153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51154       };
51155     } catch (std::exception& e) {
51156       {
51157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51158       };
51159     } catch (Dali::DaliException e) {
51160       {
51161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51162       };
51163     } catch (...) {
51164       {
51165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51166       };
51167     }
51168   }
51169
51170
51171
51172 }
51173
51174
51175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
51176   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51177   Dali::Vector< unsigned char >::SizeType arg2 ;
51178
51179   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51180   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
51181   {
51182     try {
51183       (arg1)->Reserve(arg2);
51184     } catch (std::out_of_range& e) {
51185       {
51186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51187       };
51188     } catch (std::exception& e) {
51189       {
51190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51191       };
51192     } catch (Dali::DaliException e) {
51193       {
51194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51195       };
51196     } catch (...) {
51197       {
51198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51199       };
51200     }
51201   }
51202
51203 }
51204
51205
51206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51207   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51208   Dali::Vector< unsigned char >::SizeType arg2 ;
51209
51210   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51211   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
51212   {
51213     try {
51214       (arg1)->Resize(arg2);
51215     } catch (std::out_of_range& e) {
51216       {
51217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51218       };
51219     } catch (std::exception& e) {
51220       {
51221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51222       };
51223     } catch (Dali::DaliException e) {
51224       {
51225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51226       };
51227     } catch (...) {
51228       {
51229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51230       };
51231     }
51232   }
51233
51234 }
51235
51236
51237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
51238   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51239   Dali::Vector< unsigned char >::SizeType arg2 ;
51240   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
51241   Dali::Vector< unsigned char >::ItemType temp3 ;
51242
51243   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51244   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
51245   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
51246   arg3 = &temp3;
51247   {
51248     try {
51249       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
51250     } catch (std::out_of_range& e) {
51251       {
51252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51253       };
51254     } catch (std::exception& e) {
51255       {
51256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51257       };
51258     } catch (Dali::DaliException e) {
51259       {
51260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51261       };
51262     } catch (...) {
51263       {
51264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51265       };
51266     }
51267   }
51268
51269 }
51270
51271
51272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
51273   void * jresult ;
51274   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51275   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51276   Dali::Vector< unsigned char >::Iterator result;
51277
51278   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51279   arg2 = jarg2;
51280   {
51281     try {
51282       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
51283     } catch (std::out_of_range& e) {
51284       {
51285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51286       };
51287     } catch (std::exception& e) {
51288       {
51289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51290       };
51291     } catch (Dali::DaliException e) {
51292       {
51293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51294       };
51295     } catch (...) {
51296       {
51297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51298       };
51299     }
51300   }
51301
51302   jresult = (void *)result;
51303
51304
51305   return jresult;
51306 }
51307
51308
51309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
51310   void * jresult ;
51311   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51312   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51313   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51314   Dali::Vector< unsigned char >::Iterator result;
51315
51316   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51317   arg2 = jarg2;
51318   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
51319   {
51320     try {
51321       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
51322     } catch (std::out_of_range& e) {
51323       {
51324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51325       };
51326     } catch (std::exception& e) {
51327       {
51328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51329       };
51330     } catch (Dali::DaliException e) {
51331       {
51332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51333       };
51334     } catch (...) {
51335       {
51336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51337       };
51338     }
51339   }
51340
51341   jresult = (void *)result;
51342
51343
51344   return jresult;
51345 }
51346
51347
51348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
51349   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51350   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51351
51352   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51353   arg2 = jarg2;
51354   {
51355     try {
51356       (arg1)->Remove(arg2);
51357     } catch (std::out_of_range& e) {
51358       {
51359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51360       };
51361     } catch (std::exception& e) {
51362       {
51363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51364       };
51365     } catch (Dali::DaliException e) {
51366       {
51367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51368       };
51369     } catch (...) {
51370       {
51371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51372       };
51373     }
51374   }
51375
51376
51377
51378 }
51379
51380
51381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
51382   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51383   Dali::Vector< unsigned char > *arg2 = 0 ;
51384
51385   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51386   arg2 = (Dali::Vector< unsigned char > *)jarg2;
51387   if (!arg2) {
51388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
51389     return ;
51390   }
51391   {
51392     try {
51393       (arg1)->Swap(*arg2);
51394     } catch (std::out_of_range& e) {
51395       {
51396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51397       };
51398     } catch (std::exception& e) {
51399       {
51400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51401       };
51402     } catch (Dali::DaliException e) {
51403       {
51404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51405       };
51406     } catch (...) {
51407       {
51408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51409       };
51410     }
51411   }
51412
51413 }
51414
51415
51416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
51417   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51418
51419   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51420   {
51421     try {
51422       (arg1)->Clear();
51423     } catch (std::out_of_range& e) {
51424       {
51425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51426       };
51427     } catch (std::exception& e) {
51428       {
51429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51430       };
51431     } catch (Dali::DaliException e) {
51432       {
51433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51434       };
51435     } catch (...) {
51436       {
51437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51438       };
51439     }
51440   }
51441
51442 }
51443
51444
51445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
51446   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51447
51448   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51449   {
51450     try {
51451       (arg1)->Release();
51452     } catch (std::out_of_range& e) {
51453       {
51454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51455       };
51456     } catch (std::exception& e) {
51457       {
51458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51459       };
51460     } catch (Dali::DaliException e) {
51461       {
51462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51463       };
51464     } catch (...) {
51465       {
51466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51467       };
51468     }
51469   }
51470
51471 }
51472
51473
51474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
51475   int jresult ;
51476   int result;
51477
51478   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
51479   jresult = (int)result;
51480   return jresult;
51481 }
51482
51483
51484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
51485   void * jresult ;
51486   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
51487
51488   {
51489     try {
51490       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
51491     } catch (std::out_of_range& e) {
51492       {
51493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51494       };
51495     } catch (std::exception& e) {
51496       {
51497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51498       };
51499     } catch (Dali::DaliException e) {
51500       {
51501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51502       };
51503     } catch (...) {
51504       {
51505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51506       };
51507     }
51508   }
51509
51510   jresult = (void *)result;
51511   return jresult;
51512 }
51513
51514
51515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
51516   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51517
51518   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51519   {
51520     try {
51521       delete arg1;
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_VectorUint16Pair__SWIG_1(void * jarg1) {
51545   void * jresult ;
51546   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
51547   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
51548
51549   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51550   if (!arg1) {
51551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
51552     return 0;
51553   }
51554   {
51555     try {
51556       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
51557     } catch (std::out_of_range& e) {
51558       {
51559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51560       };
51561     } catch (std::exception& e) {
51562       {
51563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51564       };
51565     } catch (Dali::DaliException e) {
51566       {
51567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51568       };
51569     } catch (...) {
51570       {
51571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51572       };
51573     }
51574   }
51575
51576   jresult = (void *)result;
51577   return jresult;
51578 }
51579
51580
51581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
51582   void * jresult ;
51583   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51584   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
51585   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
51586
51587   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51588   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
51589   if (!arg2) {
51590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
51591     return 0;
51592   }
51593   {
51594     try {
51595       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
51596     } catch (std::out_of_range& e) {
51597       {
51598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51599       };
51600     } catch (std::exception& e) {
51601       {
51602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51603       };
51604     } catch (Dali::DaliException e) {
51605       {
51606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51607       };
51608     } catch (...) {
51609       {
51610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51611       };
51612     }
51613   }
51614
51615   jresult = (void *)result;
51616   return jresult;
51617 }
51618
51619
51620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
51621   void * jresult ;
51622   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51623   Dali::Vector< Dali::Uint16Pair >::Iterator result;
51624
51625   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51626   {
51627     try {
51628       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
51629     } catch (std::out_of_range& e) {
51630       {
51631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51632       };
51633     } catch (std::exception& e) {
51634       {
51635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51636       };
51637     } catch (Dali::DaliException e) {
51638       {
51639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51640       };
51641     } catch (...) {
51642       {
51643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51644       };
51645     }
51646   }
51647
51648   jresult = (void *)result;
51649   return jresult;
51650 }
51651
51652
51653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
51654   void * jresult ;
51655   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51656   Dali::Vector< Dali::Uint16Pair >::Iterator result;
51657
51658   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51659   {
51660     try {
51661       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
51662     } catch (std::out_of_range& e) {
51663       {
51664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51665       };
51666     } catch (std::exception& e) {
51667       {
51668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51669       };
51670     } catch (Dali::DaliException e) {
51671       {
51672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51673       };
51674     } catch (...) {
51675       {
51676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51677       };
51678     }
51679   }
51680
51681   jresult = (void *)result;
51682   return jresult;
51683 }
51684
51685
51686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51687   void * jresult ;
51688   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51689   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
51690   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
51691
51692   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51693   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
51694   {
51695     try {
51696       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
51697     } catch (std::out_of_range& e) {
51698       {
51699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51700       };
51701     } catch (std::exception& e) {
51702       {
51703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51704       };
51705     } catch (Dali::DaliException e) {
51706       {
51707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51708       };
51709     } catch (...) {
51710       {
51711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51712       };
51713     }
51714   }
51715
51716   jresult = (void *)result;
51717   return jresult;
51718 }
51719
51720
51721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
51722   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51723   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
51724
51725   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51726   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
51727   if (!arg2) {
51728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
51729     return ;
51730   }
51731   {
51732     try {
51733       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
51734     } catch (std::out_of_range& e) {
51735       {
51736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51737       };
51738     } catch (std::exception& e) {
51739       {
51740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51741       };
51742     } catch (Dali::DaliException e) {
51743       {
51744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51745       };
51746     } catch (...) {
51747       {
51748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51749       };
51750     }
51751   }
51752
51753 }
51754
51755
51756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
51757   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51758   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51759   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
51760
51761   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51762   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
51763   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
51764   if (!arg3) {
51765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
51766     return ;
51767   }
51768   {
51769     try {
51770       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
51771     } catch (std::out_of_range& e) {
51772       {
51773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51774       };
51775     } catch (std::exception& e) {
51776       {
51777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51778       };
51779     } catch (Dali::DaliException e) {
51780       {
51781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51782       };
51783     } catch (...) {
51784       {
51785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51786       };
51787     }
51788   }
51789
51790 }
51791
51792
51793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51794   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51795   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51796   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51797   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51798
51799   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51800   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
51801   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
51802   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
51803   {
51804     try {
51805       (arg1)->Insert(arg2,arg3,arg4);
51806     } catch (std::out_of_range& e) {
51807       {
51808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51809       };
51810     } catch (std::exception& e) {
51811       {
51812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51813       };
51814     } catch (Dali::DaliException e) {
51815       {
51816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51817       };
51818     } catch (...) {
51819       {
51820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51821       };
51822     }
51823   }
51824
51825 }
51826
51827
51828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
51829   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51830   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
51831
51832   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51833   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
51834   {
51835     try {
51836       (arg1)->Reserve(arg2);
51837     } catch (std::out_of_range& e) {
51838       {
51839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51840       };
51841     } catch (std::exception& e) {
51842       {
51843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51844       };
51845     } catch (Dali::DaliException e) {
51846       {
51847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51848       };
51849     } catch (...) {
51850       {
51851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51852       };
51853     }
51854   }
51855
51856 }
51857
51858
51859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51860   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51861   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
51862
51863   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51864   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
51865   {
51866     try {
51867       (arg1)->Resize(arg2);
51868     } catch (std::out_of_range& e) {
51869       {
51870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51871       };
51872     } catch (std::exception& e) {
51873       {
51874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51875       };
51876     } catch (Dali::DaliException e) {
51877       {
51878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51879       };
51880     } catch (...) {
51881       {
51882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51883       };
51884     }
51885   }
51886
51887 }
51888
51889
51890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
51891   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51892   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
51893   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
51894
51895   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51896   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
51897   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
51898   if (!arg3) {
51899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
51900     return ;
51901   }
51902   {
51903     try {
51904       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
51905     } catch (std::out_of_range& e) {
51906       {
51907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51908       };
51909     } catch (std::exception& e) {
51910       {
51911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51912       };
51913     } catch (Dali::DaliException e) {
51914       {
51915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51916       };
51917     } catch (...) {
51918       {
51919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51920       };
51921     }
51922   }
51923
51924 }
51925
51926
51927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
51928   void * jresult ;
51929   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51930   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51931   Dali::Vector< Dali::Uint16Pair >::Iterator result;
51932
51933   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51934   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
51935   {
51936     try {
51937       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
51938     } catch (std::out_of_range& e) {
51939       {
51940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51941       };
51942     } catch (std::exception& e) {
51943       {
51944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51945       };
51946     } catch (Dali::DaliException e) {
51947       {
51948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51949       };
51950     } catch (...) {
51951       {
51952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51953       };
51954     }
51955   }
51956
51957   jresult = (void *)result;
51958   return jresult;
51959 }
51960
51961
51962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51963   void * jresult ;
51964   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51965   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51966   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
51967   Dali::Vector< Dali::Uint16Pair >::Iterator result;
51968
51969   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51970   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
51971   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
51972   {
51973     try {
51974       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
51975     } catch (std::out_of_range& e) {
51976       {
51977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51978       };
51979     } catch (std::exception& e) {
51980       {
51981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51982       };
51983     } catch (Dali::DaliException e) {
51984       {
51985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51986       };
51987     } catch (...) {
51988       {
51989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51990       };
51991     }
51992   }
51993
51994   jresult = (void *)result;
51995   return jresult;
51996 }
51997
51998
51999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
52000   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52001   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
52002
52003   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52004   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
52005   {
52006     try {
52007       (arg1)->Remove(arg2);
52008     } catch (std::out_of_range& e) {
52009       {
52010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52011       };
52012     } catch (std::exception& e) {
52013       {
52014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52015       };
52016     } catch (Dali::DaliException e) {
52017       {
52018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52019       };
52020     } catch (...) {
52021       {
52022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52023       };
52024     }
52025   }
52026
52027 }
52028
52029
52030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
52031   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52032   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
52033
52034   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52035   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
52036   if (!arg2) {
52037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
52038     return ;
52039   }
52040   {
52041     try {
52042       (arg1)->Swap(*arg2);
52043     } catch (std::out_of_range& e) {
52044       {
52045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52046       };
52047     } catch (std::exception& e) {
52048       {
52049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52050       };
52051     } catch (Dali::DaliException e) {
52052       {
52053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52054       };
52055     } catch (...) {
52056       {
52057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52058       };
52059     }
52060   }
52061
52062 }
52063
52064
52065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
52066   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52067
52068   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52069   {
52070     try {
52071       (arg1)->Clear();
52072     } catch (std::out_of_range& e) {
52073       {
52074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52075       };
52076     } catch (std::exception& e) {
52077       {
52078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52079       };
52080     } catch (Dali::DaliException e) {
52081       {
52082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52083       };
52084     } catch (...) {
52085       {
52086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52087       };
52088     }
52089   }
52090
52091 }
52092
52093
52094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
52095   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52096
52097   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52098   {
52099     try {
52100       (arg1)->Release();
52101     } catch (std::out_of_range& e) {
52102       {
52103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52104       };
52105     } catch (std::exception& e) {
52106       {
52107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52108       };
52109     } catch (Dali::DaliException e) {
52110       {
52111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52112       };
52113     } catch (...) {
52114       {
52115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52116       };
52117     }
52118   }
52119
52120 }
52121
52122
52123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
52124   void * jresult ;
52125   Dali::Signal< void () > *result = 0 ;
52126
52127   {
52128     try {
52129       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
52130     } catch (std::out_of_range& e) {
52131       {
52132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52133       };
52134     } catch (std::exception& e) {
52135       {
52136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52137       };
52138     } catch (Dali::DaliException e) {
52139       {
52140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52141       };
52142     } catch (...) {
52143       {
52144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52145       };
52146     }
52147   }
52148
52149   jresult = (void *)result;
52150   return jresult;
52151 }
52152
52153
52154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
52155   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52156
52157   arg1 = (Dali::Signal< void () > *)jarg1;
52158   {
52159     try {
52160       delete arg1;
52161     } catch (std::out_of_range& e) {
52162       {
52163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52164       };
52165     } catch (std::exception& e) {
52166       {
52167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52168       };
52169     } catch (Dali::DaliException e) {
52170       {
52171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52172       };
52173     } catch (...) {
52174       {
52175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52176       };
52177     }
52178   }
52179
52180 }
52181
52182
52183 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
52184   unsigned int jresult ;
52185   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52186   bool result;
52187
52188   arg1 = (Dali::Signal< void () > *)jarg1;
52189   {
52190     try {
52191       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
52192     } catch (std::out_of_range& e) {
52193       {
52194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52195       };
52196     } catch (std::exception& e) {
52197       {
52198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52199       };
52200     } catch (Dali::DaliException e) {
52201       {
52202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52203       };
52204     } catch (...) {
52205       {
52206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52207       };
52208     }
52209   }
52210
52211   jresult = result;
52212   return jresult;
52213 }
52214
52215
52216 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
52217   unsigned long jresult ;
52218   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52219   std::size_t result;
52220
52221   arg1 = (Dali::Signal< void () > *)jarg1;
52222   {
52223     try {
52224       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
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 = (unsigned long)result;
52245   return jresult;
52246 }
52247
52248
52249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
52250   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52251   void (*arg2)() = (void (*)()) 0 ;
52252
52253   arg1 = (Dali::Signal< void () > *)jarg1;
52254   arg2 = (void (*)())jarg2;
52255   {
52256     try {
52257       (arg1)->Connect(arg2);
52258     } catch (std::out_of_range& e) {
52259       {
52260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52261       };
52262     } catch (std::exception& e) {
52263       {
52264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52265       };
52266     } catch (Dali::DaliException e) {
52267       {
52268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52269       };
52270     } catch (...) {
52271       {
52272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52273       };
52274     }
52275   }
52276
52277 }
52278
52279
52280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
52281   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52282   void (*arg2)() = (void (*)()) 0 ;
52283
52284   arg1 = (Dali::Signal< void () > *)jarg1;
52285   arg2 = (void (*)())jarg2;
52286   {
52287     try {
52288       (arg1)->Disconnect(arg2);
52289     } catch (std::out_of_range& e) {
52290       {
52291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52292       };
52293     } catch (std::exception& e) {
52294       {
52295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52296       };
52297     } catch (Dali::DaliException e) {
52298       {
52299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52300       };
52301     } catch (...) {
52302       {
52303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52304       };
52305     }
52306   }
52307
52308 }
52309
52310
52311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
52312   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52313   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
52314   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
52315
52316   arg1 = (Dali::Signal< void () > *)jarg1;
52317   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
52318   arg3 = (Dali::FunctorDelegate *)jarg3;
52319   {
52320     try {
52321       (arg1)->Connect(arg2,arg3);
52322     } catch (std::out_of_range& e) {
52323       {
52324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52325       };
52326     } catch (std::exception& e) {
52327       {
52328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52329       };
52330     } catch (Dali::DaliException e) {
52331       {
52332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52333       };
52334     } catch (...) {
52335       {
52336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52337       };
52338     }
52339   }
52340
52341 }
52342
52343
52344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
52345   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52346
52347   arg1 = (Dali::Signal< void () > *)jarg1;
52348   {
52349     try {
52350       (arg1)->Emit();
52351     } catch (std::out_of_range& e) {
52352       {
52353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52354       };
52355     } catch (std::exception& e) {
52356       {
52357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52358       };
52359     } catch (Dali::DaliException e) {
52360       {
52361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52362       };
52363     } catch (...) {
52364       {
52365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52366       };
52367     }
52368   }
52369
52370 }
52371
52372
52373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
52374   unsigned int jresult ;
52375   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52376   bool result;
52377
52378   arg1 = (Dali::Signal< void (float) > *)jarg1;
52379   {
52380     try {
52381       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
52382     } catch (std::out_of_range& e) {
52383       {
52384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52385       };
52386     } catch (std::exception& e) {
52387       {
52388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52389       };
52390     } catch (Dali::DaliException e) {
52391       {
52392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52393       };
52394     } catch (...) {
52395       {
52396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52397       };
52398     }
52399   }
52400
52401   jresult = result;
52402   return jresult;
52403 }
52404
52405
52406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
52407   unsigned long jresult ;
52408   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52409   std::size_t result;
52410
52411   arg1 = (Dali::Signal< void (float) > *)jarg1;
52412   {
52413     try {
52414       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
52415     } catch (std::out_of_range& e) {
52416       {
52417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52418       };
52419     } catch (std::exception& e) {
52420       {
52421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52422       };
52423     } catch (Dali::DaliException e) {
52424       {
52425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52426       };
52427     } catch (...) {
52428       {
52429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52430       };
52431     }
52432   }
52433
52434   jresult = (unsigned long)result;
52435   return jresult;
52436 }
52437
52438
52439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
52440   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52441   void (*arg2)(float) = (void (*)(float)) 0 ;
52442
52443   arg1 = (Dali::Signal< void (float) > *)jarg1;
52444   arg2 = (void (*)(float))jarg2;
52445   {
52446     try {
52447       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
52448     } catch (std::out_of_range& e) {
52449       {
52450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52451       };
52452     } catch (std::exception& e) {
52453       {
52454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52455       };
52456     } catch (Dali::DaliException e) {
52457       {
52458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52459       };
52460     } catch (...) {
52461       {
52462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52463       };
52464     }
52465   }
52466
52467 }
52468
52469
52470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
52471   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52472   void (*arg2)(float) = (void (*)(float)) 0 ;
52473
52474   arg1 = (Dali::Signal< void (float) > *)jarg1;
52475   arg2 = (void (*)(float))jarg2;
52476   {
52477     try {
52478       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
52479     } catch (std::out_of_range& e) {
52480       {
52481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52482       };
52483     } catch (std::exception& e) {
52484       {
52485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52486       };
52487     } catch (Dali::DaliException e) {
52488       {
52489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52490       };
52491     } catch (...) {
52492       {
52493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52494       };
52495     }
52496   }
52497
52498 }
52499
52500
52501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
52502   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52503   float arg2 ;
52504
52505   arg1 = (Dali::Signal< void (float) > *)jarg1;
52506   arg2 = (float)jarg2;
52507   {
52508     try {
52509       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
52510     } catch (std::out_of_range& e) {
52511       {
52512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52513       };
52514     } catch (std::exception& e) {
52515       {
52516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52517       };
52518     } catch (Dali::DaliException e) {
52519       {
52520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52521       };
52522     } catch (...) {
52523       {
52524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52525       };
52526     }
52527   }
52528
52529 }
52530
52531
52532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
52533   void * jresult ;
52534   Dali::Signal< void (float) > *result = 0 ;
52535
52536   {
52537     try {
52538       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
52539     } catch (std::out_of_range& e) {
52540       {
52541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52542       };
52543     } catch (std::exception& e) {
52544       {
52545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52546       };
52547     } catch (Dali::DaliException e) {
52548       {
52549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52550       };
52551     } catch (...) {
52552       {
52553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52554       };
52555     }
52556   }
52557
52558   jresult = (void *)result;
52559   return jresult;
52560 }
52561
52562
52563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
52564   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52565
52566   arg1 = (Dali::Signal< void (float) > *)jarg1;
52567   {
52568     try {
52569       delete arg1;
52570     } catch (std::out_of_range& e) {
52571       {
52572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52573       };
52574     } catch (std::exception& e) {
52575       {
52576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52577       };
52578     } catch (Dali::DaliException e) {
52579       {
52580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52581       };
52582     } catch (...) {
52583       {
52584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52585       };
52586     }
52587   }
52588
52589 }
52590
52591
52592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
52593   unsigned int jresult ;
52594   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52595   bool result;
52596
52597   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52598   {
52599     try {
52600       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
52601     } catch (std::out_of_range& e) {
52602       {
52603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52604       };
52605     } catch (std::exception& e) {
52606       {
52607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52608       };
52609     } catch (Dali::DaliException e) {
52610       {
52611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52612       };
52613     } catch (...) {
52614       {
52615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52616       };
52617     }
52618   }
52619
52620   jresult = result;
52621   return jresult;
52622 }
52623
52624
52625 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
52626   unsigned long jresult ;
52627   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52628   std::size_t result;
52629
52630   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52631   {
52632     try {
52633       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
52634     } catch (std::out_of_range& e) {
52635       {
52636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52637       };
52638     } catch (std::exception& e) {
52639       {
52640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52641       };
52642     } catch (Dali::DaliException e) {
52643       {
52644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52645       };
52646     } catch (...) {
52647       {
52648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52649       };
52650     }
52651   }
52652
52653   jresult = (unsigned long)result;
52654   return jresult;
52655 }
52656
52657
52658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
52659   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52660   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
52661
52662   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52663   arg2 = (void (*)(Dali::BaseHandle))jarg2;
52664   {
52665     try {
52666       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
52667     } catch (std::out_of_range& e) {
52668       {
52669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52670       };
52671     } catch (std::exception& e) {
52672       {
52673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52674       };
52675     } catch (Dali::DaliException e) {
52676       {
52677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52678       };
52679     } catch (...) {
52680       {
52681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52682       };
52683     }
52684   }
52685
52686 }
52687
52688
52689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
52690   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52691   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
52692
52693   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52694   arg2 = (void (*)(Dali::BaseHandle))jarg2;
52695   {
52696     try {
52697       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
52698     } catch (std::out_of_range& e) {
52699       {
52700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52701       };
52702     } catch (std::exception& e) {
52703       {
52704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52705       };
52706     } catch (Dali::DaliException e) {
52707       {
52708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52709       };
52710     } catch (...) {
52711       {
52712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52713       };
52714     }
52715   }
52716
52717 }
52718
52719
52720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
52721   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52722   Dali::BaseHandle arg2 ;
52723   Dali::BaseHandle *argp2 ;
52724
52725   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52726   argp2 = (Dali::BaseHandle *)jarg2;
52727   if (!argp2) {
52728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
52729     return ;
52730   }
52731   arg2 = *argp2;
52732   {
52733     try {
52734       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
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 void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
52758   void * jresult ;
52759   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
52760
52761   {
52762     try {
52763       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
52764     } catch (std::out_of_range& e) {
52765       {
52766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52767       };
52768     } catch (std::exception& e) {
52769       {
52770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52771       };
52772     } catch (Dali::DaliException e) {
52773       {
52774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52775       };
52776     } catch (...) {
52777       {
52778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52779       };
52780     }
52781   }
52782
52783   jresult = (void *)result;
52784   return jresult;
52785 }
52786
52787
52788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
52789   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52790
52791   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52792   {
52793     try {
52794       delete arg1;
52795     } catch (std::out_of_range& e) {
52796       {
52797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52798       };
52799     } catch (std::exception& e) {
52800       {
52801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52802       };
52803     } catch (Dali::DaliException e) {
52804       {
52805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52806       };
52807     } catch (...) {
52808       {
52809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52810       };
52811     }
52812   }
52813
52814 }
52815
52816
52817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
52818   unsigned int jresult ;
52819   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52820   bool result;
52821
52822   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52823   {
52824     try {
52825       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
52826     } catch (std::out_of_range& e) {
52827       {
52828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52829       };
52830     } catch (std::exception& e) {
52831       {
52832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52833       };
52834     } catch (Dali::DaliException e) {
52835       {
52836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52837       };
52838     } catch (...) {
52839       {
52840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52841       };
52842     }
52843   }
52844
52845   jresult = result;
52846   return jresult;
52847 }
52848
52849
52850 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
52851   unsigned long jresult ;
52852   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52853   std::size_t result;
52854
52855   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52856   {
52857     try {
52858       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
52859     } catch (std::out_of_range& e) {
52860       {
52861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52862       };
52863     } catch (std::exception& e) {
52864       {
52865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52866       };
52867     } catch (Dali::DaliException e) {
52868       {
52869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52870       };
52871     } catch (...) {
52872       {
52873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52874       };
52875     }
52876   }
52877
52878   jresult = (unsigned long)result;
52879   return jresult;
52880 }
52881
52882
52883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
52884   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52885   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
52886
52887   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52888   arg2 = (void (*)(Dali::RefObject const *))jarg2;
52889   {
52890     try {
52891       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
52892     } catch (std::out_of_range& e) {
52893       {
52894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52895       };
52896     } catch (std::exception& e) {
52897       {
52898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52899       };
52900     } catch (Dali::DaliException e) {
52901       {
52902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52903       };
52904     } catch (...) {
52905       {
52906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52907       };
52908     }
52909   }
52910
52911 }
52912
52913
52914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
52915   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52916   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
52917
52918   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52919   arg2 = (void (*)(Dali::RefObject const *))jarg2;
52920   {
52921     try {
52922       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
52923     } catch (std::out_of_range& e) {
52924       {
52925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52926       };
52927     } catch (std::exception& e) {
52928       {
52929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52930       };
52931     } catch (Dali::DaliException e) {
52932       {
52933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52934       };
52935     } catch (...) {
52936       {
52937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52938       };
52939     }
52940   }
52941
52942 }
52943
52944
52945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
52946   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
52947   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
52948
52949   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
52950   arg2 = (Dali::RefObject *)jarg2;
52951   {
52952     try {
52953       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
52954     } catch (std::out_of_range& e) {
52955       {
52956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52957       };
52958     } catch (std::exception& e) {
52959       {
52960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52961       };
52962     } catch (Dali::DaliException e) {
52963       {
52964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52965       };
52966     } catch (...) {
52967       {
52968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52969       };
52970     }
52971   }
52972
52973 }
52974
52975
52976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
52977   void * jresult ;
52978   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
52979
52980   {
52981     try {
52982       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
52983     } catch (std::out_of_range& e) {
52984       {
52985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52986       };
52987     } catch (std::exception& e) {
52988       {
52989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52990       };
52991     } catch (Dali::DaliException e) {
52992       {
52993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52994       };
52995     } catch (...) {
52996       {
52997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52998       };
52999     }
53000   }
53001
53002   jresult = (void *)result;
53003   return jresult;
53004 }
53005
53006
53007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
53008   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
53009
53010   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
53011   {
53012     try {
53013       delete arg1;
53014     } catch (std::out_of_range& e) {
53015       {
53016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53017       };
53018     } catch (std::exception& e) {
53019       {
53020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53021       };
53022     } catch (Dali::DaliException e) {
53023       {
53024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53025       };
53026     } catch (...) {
53027       {
53028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53029       };
53030     }
53031   }
53032
53033 }
53034
53035
53036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
53037   unsigned int jresult ;
53038   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53039   bool result;
53040
53041   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53042   {
53043     try {
53044       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
53045     } catch (std::out_of_range& e) {
53046       {
53047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53048       };
53049     } catch (std::exception& e) {
53050       {
53051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53052       };
53053     } catch (Dali::DaliException e) {
53054       {
53055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53056       };
53057     } catch (...) {
53058       {
53059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53060       };
53061     }
53062   }
53063
53064   jresult = result;
53065   return jresult;
53066 }
53067
53068
53069 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
53070   unsigned long jresult ;
53071   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53072   std::size_t result;
53073
53074   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53075   {
53076     try {
53077       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
53078     } catch (std::out_of_range& e) {
53079       {
53080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53081       };
53082     } catch (std::exception& e) {
53083       {
53084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53085       };
53086     } catch (Dali::DaliException e) {
53087       {
53088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53089       };
53090     } catch (...) {
53091       {
53092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53093       };
53094     }
53095   }
53096
53097   jresult = (unsigned long)result;
53098   return jresult;
53099 }
53100
53101
53102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
53103   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53104   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
53105
53106   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53107   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
53108   {
53109     try {
53110       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
53111     } catch (std::out_of_range& e) {
53112       {
53113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53114       };
53115     } catch (std::exception& e) {
53116       {
53117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53118       };
53119     } catch (Dali::DaliException e) {
53120       {
53121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53122       };
53123     } catch (...) {
53124       {
53125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53126       };
53127     }
53128   }
53129
53130 }
53131
53132
53133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
53134   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53135   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
53136
53137   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53138   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
53139   {
53140     try {
53141       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
53142     } catch (std::out_of_range& e) {
53143       {
53144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53145       };
53146     } catch (std::exception& e) {
53147       {
53148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53149       };
53150     } catch (Dali::DaliException e) {
53151       {
53152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53153       };
53154     } catch (...) {
53155       {
53156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53157       };
53158     }
53159   }
53160
53161 }
53162
53163
53164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
53165   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53166   Dali::PropertyNotification *arg2 = 0 ;
53167
53168   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53169   arg2 = (Dali::PropertyNotification *)jarg2;
53170   if (!arg2) {
53171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
53172     return ;
53173   }
53174   {
53175     try {
53176       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
53177     } catch (std::out_of_range& e) {
53178       {
53179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53180       };
53181     } catch (std::exception& e) {
53182       {
53183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53184       };
53185     } catch (Dali::DaliException e) {
53186       {
53187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53188       };
53189     } catch (...) {
53190       {
53191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53192       };
53193     }
53194   }
53195
53196 }
53197
53198
53199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
53200   void * jresult ;
53201   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
53202
53203   {
53204     try {
53205       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
53206     } catch (std::out_of_range& e) {
53207       {
53208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53209       };
53210     } catch (std::exception& e) {
53211       {
53212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53213       };
53214     } catch (Dali::DaliException e) {
53215       {
53216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53217       };
53218     } catch (...) {
53219       {
53220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53221       };
53222     }
53223   }
53224
53225   jresult = (void *)result;
53226   return jresult;
53227 }
53228
53229
53230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
53231   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53232
53233   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53234   {
53235     try {
53236       delete arg1;
53237     } catch (std::out_of_range& e) {
53238       {
53239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53240       };
53241     } catch (std::exception& e) {
53242       {
53243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53244       };
53245     } catch (Dali::DaliException e) {
53246       {
53247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53248       };
53249     } catch (...) {
53250       {
53251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53252       };
53253     }
53254   }
53255
53256 }
53257
53258
53259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
53260   void * jresult ;
53261   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
53262
53263   {
53264     try {
53265       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
53266     } catch (std::out_of_range& e) {
53267       {
53268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53269       };
53270     } catch (std::exception& e) {
53271       {
53272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53273       };
53274     } catch (Dali::DaliException e) {
53275       {
53276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53277       };
53278     } catch (...) {
53279       {
53280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53281       };
53282     }
53283   }
53284
53285   jresult = (void *)result;
53286   return jresult;
53287 }
53288
53289
53290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
53291   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
53292
53293   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
53294   {
53295     try {
53296       delete arg1;
53297     } catch (std::out_of_range& e) {
53298       {
53299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53300       };
53301     } catch (std::exception& e) {
53302       {
53303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53304       };
53305     } catch (Dali::DaliException e) {
53306       {
53307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53308       };
53309     } catch (...) {
53310       {
53311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53312       };
53313     }
53314   }
53315
53316 }
53317
53318
53319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
53320   unsigned int jresult ;
53321   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53322   bool result;
53323
53324   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53325   {
53326     try {
53327       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);
53328     } catch (std::out_of_range& e) {
53329       {
53330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53331       };
53332     } catch (std::exception& e) {
53333       {
53334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53335       };
53336     } catch (Dali::DaliException e) {
53337       {
53338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53339       };
53340     } catch (...) {
53341       {
53342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53343       };
53344     }
53345   }
53346
53347   jresult = result;
53348   return jresult;
53349 }
53350
53351
53352 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53353   unsigned long jresult ;
53354   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53355   std::size_t result;
53356
53357   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53358   {
53359     try {
53360       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);
53361     } catch (std::out_of_range& e) {
53362       {
53363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53364       };
53365     } catch (std::exception& e) {
53366       {
53367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53368       };
53369     } catch (Dali::DaliException e) {
53370       {
53371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53372       };
53373     } catch (...) {
53374       {
53375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53376       };
53377     }
53378   }
53379
53380   jresult = (unsigned long)result;
53381   return jresult;
53382 }
53383
53384
53385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53386   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53387   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
53388
53389   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53390   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
53391   {
53392     try {
53393       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53394     } catch (std::out_of_range& e) {
53395       {
53396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53397       };
53398     } catch (std::exception& e) {
53399       {
53400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53401       };
53402     } catch (Dali::DaliException e) {
53403       {
53404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53405       };
53406     } catch (...) {
53407       {
53408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53409       };
53410     }
53411   }
53412
53413 }
53414
53415
53416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53417   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53418   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
53419
53420   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53421   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
53422   {
53423     try {
53424       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53425     } catch (std::out_of_range& e) {
53426       {
53427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53428       };
53429     } catch (std::exception& e) {
53430       {
53431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53432       };
53433     } catch (Dali::DaliException e) {
53434       {
53435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53436       };
53437     } catch (...) {
53438       {
53439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53440       };
53441     }
53442   }
53443
53444 }
53445
53446
53447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53448   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53449   Dali::Actor arg2 ;
53450   Dali::LongPressGesture *arg3 = 0 ;
53451   Dali::Actor *argp2 ;
53452
53453   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53454   argp2 = (Dali::Actor *)jarg2;
53455   if (!argp2) {
53456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53457     return ;
53458   }
53459   arg2 = *argp2;
53460   arg3 = (Dali::LongPressGesture *)jarg3;
53461   if (!arg3) {
53462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
53463     return ;
53464   }
53465   {
53466     try {
53467       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
53468     } catch (std::out_of_range& e) {
53469       {
53470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53471       };
53472     } catch (std::exception& e) {
53473       {
53474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53475       };
53476     } catch (Dali::DaliException e) {
53477       {
53478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53479       };
53480     } catch (...) {
53481       {
53482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53483       };
53484     }
53485   }
53486
53487 }
53488
53489
53490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
53491   void * jresult ;
53492   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
53493
53494   {
53495     try {
53496       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
53497     } catch (std::out_of_range& e) {
53498       {
53499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53500       };
53501     } catch (std::exception& e) {
53502       {
53503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53504       };
53505     } catch (Dali::DaliException e) {
53506       {
53507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53508       };
53509     } catch (...) {
53510       {
53511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53512       };
53513     }
53514   }
53515
53516   jresult = (void *)result;
53517   return jresult;
53518 }
53519
53520
53521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
53522   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53523
53524   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53525   {
53526     try {
53527       delete arg1;
53528     } catch (std::out_of_range& e) {
53529       {
53530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53531       };
53532     } catch (std::exception& e) {
53533       {
53534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53535       };
53536     } catch (Dali::DaliException e) {
53537       {
53538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53539       };
53540     } catch (...) {
53541       {
53542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53543       };
53544     }
53545   }
53546
53547 }
53548
53549
53550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
53551   unsigned int jresult ;
53552   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
53553   bool result;
53554
53555   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
53556   {
53557     try {
53558       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);
53559     } catch (std::out_of_range& e) {
53560       {
53561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53562       };
53563     } catch (std::exception& e) {
53564       {
53565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53566       };
53567     } catch (Dali::DaliException e) {
53568       {
53569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53570       };
53571     } catch (...) {
53572       {
53573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53574       };
53575     }
53576   }
53577
53578   jresult = result;
53579   return jresult;
53580 }
53581
53582
53583 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
53584   unsigned long jresult ;
53585   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
53586   std::size_t result;
53587
53588   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
53589   {
53590     try {
53591       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);
53592     } catch (std::out_of_range& e) {
53593       {
53594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53595       };
53596     } catch (std::exception& e) {
53597       {
53598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53599       };
53600     } catch (Dali::DaliException e) {
53601       {
53602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53603       };
53604     } catch (...) {
53605       {
53606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53607       };
53608     }
53609   }
53610
53611   jresult = (unsigned long)result;
53612   return jresult;
53613 }
53614
53615
53616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
53617   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
53618   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
53619
53620   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
53621   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
53622   {
53623     try {
53624       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53625     } catch (std::out_of_range& e) {
53626       {
53627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53628       };
53629     } catch (std::exception& e) {
53630       {
53631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53632       };
53633     } catch (Dali::DaliException e) {
53634       {
53635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53636       };
53637     } catch (...) {
53638       {
53639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53640       };
53641     }
53642   }
53643
53644 }
53645
53646
53647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
53648   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
53649   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
53650
53651   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
53652   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
53653   {
53654     try {
53655       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53656     } catch (std::out_of_range& e) {
53657       {
53658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53659       };
53660     } catch (std::exception& e) {
53661       {
53662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53663       };
53664     } catch (Dali::DaliException e) {
53665       {
53666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53667       };
53668     } catch (...) {
53669       {
53670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53671       };
53672     }
53673   }
53674
53675 }
53676
53677
53678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53679   unsigned int jresult ;
53680   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
53681   Dali::Actor arg2 ;
53682   Dali::TouchData *arg3 = 0 ;
53683   Dali::Actor *argp2 ;
53684   bool result;
53685
53686   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
53687   argp2 = (Dali::Actor *)jarg2;
53688   if (!argp2) {
53689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53690     return 0;
53691   }
53692   arg2 = *argp2;
53693   arg3 = (Dali::TouchData *)jarg3;
53694   if (!arg3) {
53695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
53696     return 0;
53697   }
53698   {
53699     try {
53700       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
53701     } catch (std::out_of_range& e) {
53702       {
53703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53704       };
53705     } catch (std::exception& e) {
53706       {
53707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53708       };
53709     } catch (Dali::DaliException e) {
53710       {
53711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53712       };
53713     } catch (...) {
53714       {
53715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53716       };
53717     }
53718   }
53719
53720   jresult = result;
53721   return jresult;
53722 }
53723
53724
53725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
53726   void * jresult ;
53727   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
53728
53729   {
53730     try {
53731       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
53732     } catch (std::out_of_range& e) {
53733       {
53734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53735       };
53736     } catch (std::exception& e) {
53737       {
53738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53739       };
53740     } catch (Dali::DaliException e) {
53741       {
53742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53743       };
53744     } catch (...) {
53745       {
53746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53747       };
53748     }
53749   }
53750
53751   jresult = (void *)result;
53752   return jresult;
53753 }
53754
53755
53756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
53757   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
53758
53759   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
53760   {
53761     try {
53762       delete arg1;
53763     } catch (std::out_of_range& e) {
53764       {
53765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53766       };
53767     } catch (std::exception& e) {
53768       {
53769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53770       };
53771     } catch (Dali::DaliException e) {
53772       {
53773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53774       };
53775     } catch (...) {
53776       {
53777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53778       };
53779     }
53780   }
53781
53782 }
53783
53784
53785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
53786   unsigned int jresult ;
53787   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53788   bool result;
53789
53790   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53791   {
53792     try {
53793       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);
53794     } catch (std::out_of_range& e) {
53795       {
53796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53797       };
53798     } catch (std::exception& e) {
53799       {
53800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53801       };
53802     } catch (Dali::DaliException e) {
53803       {
53804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53805       };
53806     } catch (...) {
53807       {
53808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53809       };
53810     }
53811   }
53812
53813   jresult = result;
53814   return jresult;
53815 }
53816
53817
53818 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
53819   unsigned long jresult ;
53820   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53821   std::size_t result;
53822
53823   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53824   {
53825     try {
53826       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);
53827     } catch (std::out_of_range& e) {
53828       {
53829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53830       };
53831     } catch (std::exception& e) {
53832       {
53833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53834       };
53835     } catch (Dali::DaliException e) {
53836       {
53837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53838       };
53839     } catch (...) {
53840       {
53841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53842       };
53843     }
53844   }
53845
53846   jresult = (unsigned long)result;
53847   return jresult;
53848 }
53849
53850
53851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
53852   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53853   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
53854
53855   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53856   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
53857   {
53858     try {
53859       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53860     } catch (std::out_of_range& e) {
53861       {
53862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53863       };
53864     } catch (std::exception& e) {
53865       {
53866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53867       };
53868     } catch (Dali::DaliException e) {
53869       {
53870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53871       };
53872     } catch (...) {
53873       {
53874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53875       };
53876     }
53877   }
53878
53879 }
53880
53881
53882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
53883   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53884   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
53885
53886   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53887   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
53888   {
53889     try {
53890       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53891     } catch (std::out_of_range& e) {
53892       {
53893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53894       };
53895     } catch (std::exception& e) {
53896       {
53897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53898       };
53899     } catch (Dali::DaliException e) {
53900       {
53901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53902       };
53903     } catch (...) {
53904       {
53905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53906       };
53907     }
53908   }
53909
53910 }
53911
53912
53913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53914   unsigned int jresult ;
53915   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53916   Dali::Actor arg2 ;
53917   Dali::HoverEvent *arg3 = 0 ;
53918   Dali::Actor *argp2 ;
53919   bool result;
53920
53921   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53922   argp2 = (Dali::Actor *)jarg2;
53923   if (!argp2) {
53924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53925     return 0;
53926   }
53927   arg2 = *argp2;
53928   arg3 = (Dali::HoverEvent *)jarg3;
53929   if (!arg3) {
53930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
53931     return 0;
53932   }
53933   {
53934     try {
53935       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
53936     } catch (std::out_of_range& e) {
53937       {
53938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53939       };
53940     } catch (std::exception& e) {
53941       {
53942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53943       };
53944     } catch (Dali::DaliException e) {
53945       {
53946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53947       };
53948     } catch (...) {
53949       {
53950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53951       };
53952     }
53953   }
53954
53955   jresult = result;
53956   return jresult;
53957 }
53958
53959
53960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
53961   void * jresult ;
53962   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
53963
53964   {
53965     try {
53966       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
53967     } catch (std::out_of_range& e) {
53968       {
53969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53970       };
53971     } catch (std::exception& e) {
53972       {
53973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53974       };
53975     } catch (Dali::DaliException e) {
53976       {
53977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53978       };
53979     } catch (...) {
53980       {
53981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53982       };
53983     }
53984   }
53985
53986   jresult = (void *)result;
53987   return jresult;
53988 }
53989
53990
53991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
53992   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
53993
53994   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
53995   {
53996     try {
53997       delete arg1;
53998     } catch (std::out_of_range& e) {
53999       {
54000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54001       };
54002     } catch (std::exception& e) {
54003       {
54004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54005       };
54006     } catch (Dali::DaliException e) {
54007       {
54008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54009       };
54010     } catch (...) {
54011       {
54012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54013       };
54014     }
54015   }
54016
54017 }
54018
54019
54020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
54021   unsigned int jresult ;
54022   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54023   bool result;
54024
54025   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54026   {
54027     try {
54028       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);
54029     } catch (std::out_of_range& e) {
54030       {
54031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54032       };
54033     } catch (std::exception& e) {
54034       {
54035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54036       };
54037     } catch (Dali::DaliException e) {
54038       {
54039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54040       };
54041     } catch (...) {
54042       {
54043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54044       };
54045     }
54046   }
54047
54048   jresult = result;
54049   return jresult;
54050 }
54051
54052
54053 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
54054   unsigned long jresult ;
54055   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54056   std::size_t result;
54057
54058   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54059   {
54060     try {
54061       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);
54062     } catch (std::out_of_range& e) {
54063       {
54064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54065       };
54066     } catch (std::exception& e) {
54067       {
54068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54069       };
54070     } catch (Dali::DaliException e) {
54071       {
54072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54073       };
54074     } catch (...) {
54075       {
54076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54077       };
54078     }
54079   }
54080
54081   jresult = (unsigned long)result;
54082   return jresult;
54083 }
54084
54085
54086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
54087   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54088   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
54089
54090   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54091   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
54092   {
54093     try {
54094       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54095     } catch (std::out_of_range& e) {
54096       {
54097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54098       };
54099     } catch (std::exception& e) {
54100       {
54101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54102       };
54103     } catch (Dali::DaliException e) {
54104       {
54105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54106       };
54107     } catch (...) {
54108       {
54109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54110       };
54111     }
54112   }
54113
54114 }
54115
54116
54117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
54118   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54119   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
54120
54121   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54122   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
54123   {
54124     try {
54125       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54126     } catch (std::out_of_range& e) {
54127       {
54128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54129       };
54130     } catch (std::exception& e) {
54131       {
54132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54133       };
54134     } catch (Dali::DaliException e) {
54135       {
54136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54137       };
54138     } catch (...) {
54139       {
54140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54141       };
54142     }
54143   }
54144
54145 }
54146
54147
54148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54149   unsigned int jresult ;
54150   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54151   Dali::Actor arg2 ;
54152   Dali::WheelEvent *arg3 = 0 ;
54153   Dali::Actor *argp2 ;
54154   bool result;
54155
54156   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54157   argp2 = (Dali::Actor *)jarg2;
54158   if (!argp2) {
54159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54160     return 0;
54161   }
54162   arg2 = *argp2;
54163   arg3 = (Dali::WheelEvent *)jarg3;
54164   if (!arg3) {
54165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
54166     return 0;
54167   }
54168   {
54169     try {
54170       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
54171     } catch (std::out_of_range& e) {
54172       {
54173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54174       };
54175     } catch (std::exception& e) {
54176       {
54177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54178       };
54179     } catch (Dali::DaliException e) {
54180       {
54181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54182       };
54183     } catch (...) {
54184       {
54185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54186       };
54187     }
54188   }
54189
54190   jresult = result;
54191   return jresult;
54192 }
54193
54194
54195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
54196   void * jresult ;
54197   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
54198
54199   {
54200     try {
54201       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
54202     } catch (std::out_of_range& e) {
54203       {
54204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54205       };
54206     } catch (std::exception& e) {
54207       {
54208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54209       };
54210     } catch (Dali::DaliException e) {
54211       {
54212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54213       };
54214     } catch (...) {
54215       {
54216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54217       };
54218     }
54219   }
54220
54221   jresult = (void *)result;
54222   return jresult;
54223 }
54224
54225
54226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
54227   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54228
54229   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54230   {
54231     try {
54232       delete arg1;
54233     } catch (std::out_of_range& e) {
54234       {
54235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54236       };
54237     } catch (std::exception& e) {
54238       {
54239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54240       };
54241     } catch (Dali::DaliException e) {
54242       {
54243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54244       };
54245     } catch (...) {
54246       {
54247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54248       };
54249     }
54250   }
54251
54252 }
54253
54254
54255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
54256   unsigned int jresult ;
54257   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54258   bool result;
54259
54260   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54261   {
54262     try {
54263       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
54264     } catch (std::out_of_range& e) {
54265       {
54266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54267       };
54268     } catch (std::exception& e) {
54269       {
54270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54271       };
54272     } catch (Dali::DaliException e) {
54273       {
54274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54275       };
54276     } catch (...) {
54277       {
54278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54279       };
54280     }
54281   }
54282
54283   jresult = result;
54284   return jresult;
54285 }
54286
54287
54288 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
54289   unsigned long jresult ;
54290   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54291   std::size_t result;
54292
54293   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54294   {
54295     try {
54296       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
54297     } catch (std::out_of_range& e) {
54298       {
54299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54300       };
54301     } catch (std::exception& e) {
54302       {
54303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54304       };
54305     } catch (Dali::DaliException e) {
54306       {
54307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54308       };
54309     } catch (...) {
54310       {
54311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54312       };
54313     }
54314   }
54315
54316   jresult = (unsigned long)result;
54317   return jresult;
54318 }
54319
54320
54321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
54322   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54323   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
54324
54325   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54326   arg2 = (void (*)(Dali::Actor))jarg2;
54327   {
54328     try {
54329       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
54330     } catch (std::out_of_range& e) {
54331       {
54332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54333       };
54334     } catch (std::exception& e) {
54335       {
54336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54337       };
54338     } catch (Dali::DaliException e) {
54339       {
54340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54341       };
54342     } catch (...) {
54343       {
54344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54345       };
54346     }
54347   }
54348
54349 }
54350
54351
54352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
54353   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54354   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
54355
54356   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54357   arg2 = (void (*)(Dali::Actor))jarg2;
54358   {
54359     try {
54360       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
54361     } catch (std::out_of_range& e) {
54362       {
54363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54364       };
54365     } catch (std::exception& e) {
54366       {
54367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54368       };
54369     } catch (Dali::DaliException e) {
54370       {
54371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54372       };
54373     } catch (...) {
54374       {
54375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54376       };
54377     }
54378   }
54379
54380 }
54381
54382
54383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
54384   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54385   Dali::Actor arg2 ;
54386   Dali::Actor *argp2 ;
54387
54388   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54389   argp2 = (Dali::Actor *)jarg2;
54390   if (!argp2) {
54391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54392     return ;
54393   }
54394   arg2 = *argp2;
54395   {
54396     try {
54397       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
54398     } catch (std::out_of_range& e) {
54399       {
54400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54401       };
54402     } catch (std::exception& e) {
54403       {
54404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54405       };
54406     } catch (Dali::DaliException e) {
54407       {
54408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54409       };
54410     } catch (...) {
54411       {
54412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54413       };
54414     }
54415   }
54416
54417 }
54418
54419
54420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
54421   void * jresult ;
54422   Dali::Signal< void (Dali::Actor) > *result = 0 ;
54423
54424   {
54425     try {
54426       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
54427     } catch (std::out_of_range& e) {
54428       {
54429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54430       };
54431     } catch (std::exception& e) {
54432       {
54433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54434       };
54435     } catch (Dali::DaliException e) {
54436       {
54437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54438       };
54439     } catch (...) {
54440       {
54441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54442       };
54443     }
54444   }
54445
54446   jresult = (void *)result;
54447   return jresult;
54448 }
54449
54450
54451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
54452   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54453
54454   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54455   {
54456     try {
54457       delete arg1;
54458     } catch (std::out_of_range& e) {
54459       {
54460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54461       };
54462     } catch (std::exception& e) {
54463       {
54464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54465       };
54466     } catch (Dali::DaliException e) {
54467       {
54468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54469       };
54470     } catch (...) {
54471       {
54472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54473       };
54474     }
54475   }
54476
54477 }
54478
54479
54480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
54481   unsigned int jresult ;
54482   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
54483   bool result;
54484
54485   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
54486   {
54487     try {
54488       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
54489     } catch (std::out_of_range& e) {
54490       {
54491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54492       };
54493     } catch (std::exception& e) {
54494       {
54495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54496       };
54497     } catch (Dali::DaliException e) {
54498       {
54499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54500       };
54501     } catch (...) {
54502       {
54503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54504       };
54505     }
54506   }
54507
54508   jresult = result;
54509   return jresult;
54510 }
54511
54512
54513 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
54514   unsigned long jresult ;
54515   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
54516   std::size_t result;
54517
54518   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
54519   {
54520     try {
54521       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
54522     } catch (std::out_of_range& e) {
54523       {
54524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54525       };
54526     } catch (std::exception& e) {
54527       {
54528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54529       };
54530     } catch (Dali::DaliException e) {
54531       {
54532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54533       };
54534     } catch (...) {
54535       {
54536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54537       };
54538     }
54539   }
54540
54541   jresult = (unsigned long)result;
54542   return jresult;
54543 }
54544
54545
54546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
54547   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
54548   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
54549
54550   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
54551   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
54552   {
54553     try {
54554       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54555     } catch (std::out_of_range& e) {
54556       {
54557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54558       };
54559     } catch (std::exception& e) {
54560       {
54561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54562       };
54563     } catch (Dali::DaliException e) {
54564       {
54565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54566       };
54567     } catch (...) {
54568       {
54569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54570       };
54571     }
54572   }
54573
54574 }
54575
54576
54577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
54578   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
54579   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
54580
54581   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
54582   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
54583   {
54584     try {
54585       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54586     } catch (std::out_of_range& e) {
54587       {
54588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54589       };
54590     } catch (std::exception& e) {
54591       {
54592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54593       };
54594     } catch (Dali::DaliException e) {
54595       {
54596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54597       };
54598     } catch (...) {
54599       {
54600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54601       };
54602     }
54603   }
54604
54605 }
54606
54607
54608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
54609   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
54610   Dali::KeyEvent *arg2 = 0 ;
54611
54612   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
54613   arg2 = (Dali::KeyEvent *)jarg2;
54614   if (!arg2) {
54615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
54616     return ;
54617   }
54618   {
54619     try {
54620       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
54621     } catch (std::out_of_range& e) {
54622       {
54623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54624       };
54625     } catch (std::exception& e) {
54626       {
54627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54628       };
54629     } catch (Dali::DaliException e) {
54630       {
54631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54632       };
54633     } catch (...) {
54634       {
54635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54636       };
54637     }
54638   }
54639
54640 }
54641
54642
54643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
54644   void * jresult ;
54645   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
54646
54647   {
54648     try {
54649       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
54650     } catch (std::out_of_range& e) {
54651       {
54652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54653       };
54654     } catch (std::exception& e) {
54655       {
54656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54657       };
54658     } catch (Dali::DaliException e) {
54659       {
54660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54661       };
54662     } catch (...) {
54663       {
54664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54665       };
54666     }
54667   }
54668
54669   jresult = (void *)result;
54670   return jresult;
54671 }
54672
54673
54674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
54675   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
54676
54677   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
54678   {
54679     try {
54680       delete arg1;
54681     } catch (std::out_of_range& e) {
54682       {
54683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54684       };
54685     } catch (std::exception& e) {
54686       {
54687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54688       };
54689     } catch (Dali::DaliException e) {
54690       {
54691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54692       };
54693     } catch (...) {
54694       {
54695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54696       };
54697     }
54698   }
54699
54700 }
54701
54702
54703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
54704   unsigned int jresult ;
54705   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
54706   bool result;
54707
54708   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54709   {
54710     try {
54711       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
54712     } catch (std::out_of_range& e) {
54713       {
54714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54715       };
54716     } catch (std::exception& e) {
54717       {
54718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54719       };
54720     } catch (Dali::DaliException e) {
54721       {
54722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54723       };
54724     } catch (...) {
54725       {
54726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54727       };
54728     }
54729   }
54730
54731   jresult = result;
54732   return jresult;
54733 }
54734
54735
54736 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
54737   unsigned long jresult ;
54738   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
54739   std::size_t result;
54740
54741   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54742   {
54743     try {
54744       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
54745     } catch (std::out_of_range& e) {
54746       {
54747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54748       };
54749     } catch (std::exception& e) {
54750       {
54751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54752       };
54753     } catch (Dali::DaliException e) {
54754       {
54755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54756       };
54757     } catch (...) {
54758       {
54759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54760       };
54761     }
54762   }
54763
54764   jresult = (unsigned long)result;
54765   return jresult;
54766 }
54767
54768
54769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
54770   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
54771   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
54772
54773   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54774   arg2 = (void (*)(Dali::TouchData const &))jarg2;
54775   {
54776     try {
54777       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54778     } catch (std::out_of_range& e) {
54779       {
54780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54781       };
54782     } catch (std::exception& e) {
54783       {
54784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54785       };
54786     } catch (Dali::DaliException e) {
54787       {
54788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54789       };
54790     } catch (...) {
54791       {
54792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54793       };
54794     }
54795   }
54796
54797 }
54798
54799
54800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
54801   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
54802   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
54803
54804   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54805   arg2 = (void (*)(Dali::TouchData const &))jarg2;
54806   {
54807     try {
54808       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54809     } catch (std::out_of_range& e) {
54810       {
54811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54812       };
54813     } catch (std::exception& e) {
54814       {
54815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54816       };
54817     } catch (Dali::DaliException e) {
54818       {
54819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54820       };
54821     } catch (...) {
54822       {
54823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54824       };
54825     }
54826   }
54827
54828 }
54829
54830
54831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
54832   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
54833   Dali::TouchData *arg2 = 0 ;
54834
54835   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54836   arg2 = (Dali::TouchData *)jarg2;
54837   if (!arg2) {
54838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
54839     return ;
54840   }
54841   {
54842     try {
54843       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
54844     } catch (std::out_of_range& e) {
54845       {
54846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54847       };
54848     } catch (std::exception& e) {
54849       {
54850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54851       };
54852     } catch (Dali::DaliException e) {
54853       {
54854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54855       };
54856     } catch (...) {
54857       {
54858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54859       };
54860     }
54861   }
54862
54863 }
54864
54865
54866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
54867   void * jresult ;
54868   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
54869
54870   {
54871     try {
54872       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
54873     } catch (std::out_of_range& e) {
54874       {
54875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54876       };
54877     } catch (std::exception& e) {
54878       {
54879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54880       };
54881     } catch (Dali::DaliException e) {
54882       {
54883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54884       };
54885     } catch (...) {
54886       {
54887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54888       };
54889     }
54890   }
54891
54892   jresult = (void *)result;
54893   return jresult;
54894 }
54895
54896
54897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
54898   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
54899
54900   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
54901   {
54902     try {
54903       delete arg1;
54904     } catch (std::out_of_range& e) {
54905       {
54906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54907       };
54908     } catch (std::exception& e) {
54909       {
54910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54911       };
54912     } catch (Dali::DaliException e) {
54913       {
54914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54915       };
54916     } catch (...) {
54917       {
54918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54919       };
54920     }
54921   }
54922
54923 }
54924
54925
54926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
54927   unsigned int jresult ;
54928   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
54929   bool result;
54930
54931   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
54932   {
54933     try {
54934       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
54935     } catch (std::out_of_range& e) {
54936       {
54937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54938       };
54939     } catch (std::exception& e) {
54940       {
54941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54942       };
54943     } catch (Dali::DaliException e) {
54944       {
54945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54946       };
54947     } catch (...) {
54948       {
54949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54950       };
54951     }
54952   }
54953
54954   jresult = result;
54955   return jresult;
54956 }
54957
54958
54959 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
54960   unsigned long jresult ;
54961   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
54962   std::size_t result;
54963
54964   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
54965   {
54966     try {
54967       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
54968     } catch (std::out_of_range& e) {
54969       {
54970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54971       };
54972     } catch (std::exception& e) {
54973       {
54974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54975       };
54976     } catch (Dali::DaliException e) {
54977       {
54978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54979       };
54980     } catch (...) {
54981       {
54982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54983       };
54984     }
54985   }
54986
54987   jresult = (unsigned long)result;
54988   return jresult;
54989 }
54990
54991
54992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
54993   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
54994   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
54995
54996   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
54997   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
54998   {
54999     try {
55000       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55001     } catch (std::out_of_range& e) {
55002       {
55003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55004       };
55005     } catch (std::exception& e) {
55006       {
55007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55008       };
55009     } catch (Dali::DaliException e) {
55010       {
55011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55012       };
55013     } catch (...) {
55014       {
55015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55016       };
55017     }
55018   }
55019
55020 }
55021
55022
55023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55024   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
55025   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
55026
55027   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
55028   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
55029   {
55030     try {
55031       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55032     } catch (std::out_of_range& e) {
55033       {
55034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55035       };
55036     } catch (std::exception& e) {
55037       {
55038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55039       };
55040     } catch (Dali::DaliException e) {
55041       {
55042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55043       };
55044     } catch (...) {
55045       {
55046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55047       };
55048     }
55049   }
55050
55051 }
55052
55053
55054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
55055   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
55056   Dali::WheelEvent *arg2 = 0 ;
55057
55058   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
55059   arg2 = (Dali::WheelEvent *)jarg2;
55060   if (!arg2) {
55061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55062     return ;
55063   }
55064   {
55065     try {
55066       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
55067     } catch (std::out_of_range& e) {
55068       {
55069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55070       };
55071     } catch (std::exception& e) {
55072       {
55073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55074       };
55075     } catch (Dali::DaliException e) {
55076       {
55077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55078       };
55079     } catch (...) {
55080       {
55081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55082       };
55083     }
55084   }
55085
55086 }
55087
55088
55089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
55090   void * jresult ;
55091   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
55092
55093   {
55094     try {
55095       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
55096     } catch (std::out_of_range& e) {
55097       {
55098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55099       };
55100     } catch (std::exception& e) {
55101       {
55102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55103       };
55104     } catch (Dali::DaliException e) {
55105       {
55106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55107       };
55108     } catch (...) {
55109       {
55110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55111       };
55112     }
55113   }
55114
55115   jresult = (void *)result;
55116   return jresult;
55117 }
55118
55119
55120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
55121   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
55122
55123   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
55124   {
55125     try {
55126       delete arg1;
55127     } catch (std::out_of_range& e) {
55128       {
55129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55130       };
55131     } catch (std::exception& e) {
55132       {
55133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55134       };
55135     } catch (Dali::DaliException e) {
55136       {
55137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55138       };
55139     } catch (...) {
55140       {
55141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55142       };
55143     }
55144   }
55145
55146 }
55147
55148
55149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
55150   void * jresult ;
55151   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
55152
55153   {
55154     try {
55155       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
55156     } catch (std::out_of_range& e) {
55157       {
55158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55159       };
55160     } catch (std::exception& e) {
55161       {
55162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55163       };
55164     } catch (Dali::DaliException e) {
55165       {
55166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55167       };
55168     } catch (...) {
55169       {
55170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55171       };
55172     }
55173   }
55174
55175   jresult = (void *)result;
55176   return jresult;
55177 }
55178
55179
55180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
55181   void * jresult ;
55182   Dali::Radian arg1 ;
55183   Dali::Radian arg2 ;
55184   Dali::Radian *argp1 ;
55185   Dali::Radian *argp2 ;
55186   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
55187
55188   argp1 = (Dali::Radian *)jarg1;
55189   if (!argp1) {
55190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
55191     return 0;
55192   }
55193   arg1 = *argp1;
55194   argp2 = (Dali::Radian *)jarg2;
55195   if (!argp2) {
55196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
55197     return 0;
55198   }
55199   arg2 = *argp2;
55200   {
55201     try {
55202       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
55203     } catch (std::out_of_range& e) {
55204       {
55205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55206       };
55207     } catch (std::exception& e) {
55208       {
55209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55210       };
55211     } catch (Dali::DaliException e) {
55212       {
55213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55214       };
55215     } catch (...) {
55216       {
55217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55218       };
55219     }
55220   }
55221
55222   jresult = (void *)result;
55223   return jresult;
55224 }
55225
55226
55227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
55228   void * jresult ;
55229   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
55230   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
55231
55232   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55233   if (!arg1) {
55234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
55235     return 0;
55236   }
55237   {
55238     try {
55239       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
55240     } catch (std::out_of_range& e) {
55241       {
55242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55243       };
55244     } catch (std::exception& e) {
55245       {
55246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55247       };
55248     } catch (Dali::DaliException e) {
55249       {
55250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55251       };
55252     } catch (...) {
55253       {
55254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55255       };
55256     }
55257   }
55258
55259   jresult = (void *)result;
55260   return jresult;
55261 }
55262
55263
55264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
55265   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
55266   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
55267
55268   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55269   arg2 = (Dali::Radian *)jarg2;
55270   if (arg1) (arg1)->first = *arg2;
55271 }
55272
55273
55274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
55275   void * jresult ;
55276   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
55277   Dali::Radian *result = 0 ;
55278
55279   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55280   result = (Dali::Radian *)& ((arg1)->first);
55281   jresult = (void *)result;
55282   return jresult;
55283 }
55284
55285
55286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
55287   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
55288   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
55289
55290   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55291   arg2 = (Dali::Radian *)jarg2;
55292   if (arg1) (arg1)->second = *arg2;
55293 }
55294
55295
55296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
55297   void * jresult ;
55298   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
55299   Dali::Radian *result = 0 ;
55300
55301   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55302   result = (Dali::Radian *)& ((arg1)->second);
55303   jresult = (void *)result;
55304   return jresult;
55305 }
55306
55307
55308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
55309   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
55310
55311   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55312   {
55313     try {
55314       delete arg1;
55315     } catch (std::out_of_range& e) {
55316       {
55317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55318       };
55319     } catch (std::exception& e) {
55320       {
55321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55322       };
55323     } catch (Dali::DaliException e) {
55324       {
55325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55326       };
55327     } catch (...) {
55328       {
55329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55330       };
55331     }
55332   }
55333
55334 }
55335
55336
55337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
55338   unsigned int jresult ;
55339   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55340   bool result;
55341
55342   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55343   {
55344     try {
55345       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);
55346     } catch (std::out_of_range& e) {
55347       {
55348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55349       };
55350     } catch (std::exception& e) {
55351       {
55352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55353       };
55354     } catch (Dali::DaliException e) {
55355       {
55356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55357       };
55358     } catch (...) {
55359       {
55360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55361       };
55362     }
55363   }
55364
55365   jresult = result;
55366   return jresult;
55367 }
55368
55369
55370 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55371   unsigned long jresult ;
55372   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55373   std::size_t result;
55374
55375   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55376   {
55377     try {
55378       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);
55379     } catch (std::out_of_range& e) {
55380       {
55381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55382       };
55383     } catch (std::exception& e) {
55384       {
55385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55386       };
55387     } catch (Dali::DaliException e) {
55388       {
55389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55390       };
55391     } catch (...) {
55392       {
55393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55394       };
55395     }
55396   }
55397
55398   jresult = (unsigned long)result;
55399   return jresult;
55400 }
55401
55402
55403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55404   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55405   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
55406
55407   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55408   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
55409   {
55410     try {
55411       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55412     } catch (std::out_of_range& e) {
55413       {
55414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55415       };
55416     } catch (std::exception& e) {
55417       {
55418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55419       };
55420     } catch (Dali::DaliException e) {
55421       {
55422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55423       };
55424     } catch (...) {
55425       {
55426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55427       };
55428     }
55429   }
55430
55431 }
55432
55433
55434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55435   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55436   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
55437
55438   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55439   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
55440   {
55441     try {
55442       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55443     } catch (std::out_of_range& e) {
55444       {
55445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55446       };
55447     } catch (std::exception& e) {
55448       {
55449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55450       };
55451     } catch (Dali::DaliException e) {
55452       {
55453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55454       };
55455     } catch (...) {
55456       {
55457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55458       };
55459     }
55460   }
55461
55462 }
55463
55464
55465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55466   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55467   Dali::Actor arg2 ;
55468   Dali::PanGesture *arg3 = 0 ;
55469   Dali::Actor *argp2 ;
55470
55471   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55472   argp2 = (Dali::Actor *)jarg2;
55473   if (!argp2) {
55474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55475     return ;
55476   }
55477   arg2 = *argp2;
55478   arg3 = (Dali::PanGesture *)jarg3;
55479   if (!arg3) {
55480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
55481     return ;
55482   }
55483   {
55484     try {
55485       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
55486     } catch (std::out_of_range& e) {
55487       {
55488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55489       };
55490     } catch (std::exception& e) {
55491       {
55492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55493       };
55494     } catch (Dali::DaliException e) {
55495       {
55496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55497       };
55498     } catch (...) {
55499       {
55500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55501       };
55502     }
55503   }
55504
55505 }
55506
55507
55508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
55509   void * jresult ;
55510   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
55511
55512   {
55513     try {
55514       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
55515     } catch (std::out_of_range& e) {
55516       {
55517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55518       };
55519     } catch (std::exception& e) {
55520       {
55521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55522       };
55523     } catch (Dali::DaliException e) {
55524       {
55525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55526       };
55527     } catch (...) {
55528       {
55529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55530       };
55531     }
55532   }
55533
55534   jresult = (void *)result;
55535   return jresult;
55536 }
55537
55538
55539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
55540   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55541
55542   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55543   {
55544     try {
55545       delete arg1;
55546     } catch (std::out_of_range& e) {
55547       {
55548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55549       };
55550     } catch (std::exception& e) {
55551       {
55552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55553       };
55554     } catch (Dali::DaliException e) {
55555       {
55556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55557       };
55558     } catch (...) {
55559       {
55560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55561       };
55562     }
55563   }
55564
55565 }
55566
55567
55568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
55569   unsigned int jresult ;
55570   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
55571   bool result;
55572
55573   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
55574   {
55575     try {
55576       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);
55577     } catch (std::out_of_range& e) {
55578       {
55579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55580       };
55581     } catch (std::exception& e) {
55582       {
55583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55584       };
55585     } catch (Dali::DaliException e) {
55586       {
55587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55588       };
55589     } catch (...) {
55590       {
55591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55592       };
55593     }
55594   }
55595
55596   jresult = result;
55597   return jresult;
55598 }
55599
55600
55601 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55602   unsigned long jresult ;
55603   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
55604   std::size_t result;
55605
55606   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
55607   {
55608     try {
55609       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);
55610     } catch (std::out_of_range& e) {
55611       {
55612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55613       };
55614     } catch (std::exception& e) {
55615       {
55616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55617       };
55618     } catch (Dali::DaliException e) {
55619       {
55620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55621       };
55622     } catch (...) {
55623       {
55624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55625       };
55626     }
55627   }
55628
55629   jresult = (unsigned long)result;
55630   return jresult;
55631 }
55632
55633
55634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55635   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
55636   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
55637
55638   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
55639   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
55640   {
55641     try {
55642       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55643     } catch (std::out_of_range& e) {
55644       {
55645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55646       };
55647     } catch (std::exception& e) {
55648       {
55649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55650       };
55651     } catch (Dali::DaliException e) {
55652       {
55653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55654       };
55655     } catch (...) {
55656       {
55657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55658       };
55659     }
55660   }
55661
55662 }
55663
55664
55665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55666   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
55667   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
55668
55669   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
55670   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
55671   {
55672     try {
55673       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55674     } catch (std::out_of_range& e) {
55675       {
55676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55677       };
55678     } catch (std::exception& e) {
55679       {
55680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55681       };
55682     } catch (Dali::DaliException e) {
55683       {
55684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55685       };
55686     } catch (...) {
55687       {
55688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55689       };
55690     }
55691   }
55692
55693 }
55694
55695
55696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55697   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
55698   Dali::Actor arg2 ;
55699   Dali::PinchGesture *arg3 = 0 ;
55700   Dali::Actor *argp2 ;
55701
55702   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
55703   argp2 = (Dali::Actor *)jarg2;
55704   if (!argp2) {
55705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55706     return ;
55707   }
55708   arg2 = *argp2;
55709   arg3 = (Dali::PinchGesture *)jarg3;
55710   if (!arg3) {
55711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
55712     return ;
55713   }
55714   {
55715     try {
55716       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
55717     } catch (std::out_of_range& e) {
55718       {
55719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55720       };
55721     } catch (std::exception& e) {
55722       {
55723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55724       };
55725     } catch (Dali::DaliException e) {
55726       {
55727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55728       };
55729     } catch (...) {
55730       {
55731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55732       };
55733     }
55734   }
55735
55736 }
55737
55738
55739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
55740   void * jresult ;
55741   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
55742
55743   {
55744     try {
55745       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
55746     } catch (std::out_of_range& e) {
55747       {
55748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55749       };
55750     } catch (std::exception& e) {
55751       {
55752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55753       };
55754     } catch (Dali::DaliException e) {
55755       {
55756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55757       };
55758     } catch (...) {
55759       {
55760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55761       };
55762     }
55763   }
55764
55765   jresult = (void *)result;
55766   return jresult;
55767 }
55768
55769
55770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
55771   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
55772
55773   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
55774   {
55775     try {
55776       delete arg1;
55777     } catch (std::out_of_range& e) {
55778       {
55779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55780       };
55781     } catch (std::exception& e) {
55782       {
55783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55784       };
55785     } catch (Dali::DaliException e) {
55786       {
55787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55788       };
55789     } catch (...) {
55790       {
55791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55792       };
55793     }
55794   }
55795
55796 }
55797
55798
55799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
55800   unsigned int jresult ;
55801   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55802   bool result;
55803
55804   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55805   {
55806     try {
55807       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);
55808     } catch (std::out_of_range& e) {
55809       {
55810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55811       };
55812     } catch (std::exception& e) {
55813       {
55814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55815       };
55816     } catch (Dali::DaliException e) {
55817       {
55818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55819       };
55820     } catch (...) {
55821       {
55822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55823       };
55824     }
55825   }
55826
55827   jresult = result;
55828   return jresult;
55829 }
55830
55831
55832 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55833   unsigned long jresult ;
55834   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55835   std::size_t result;
55836
55837   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55838   {
55839     try {
55840       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);
55841     } catch (std::out_of_range& e) {
55842       {
55843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55844       };
55845     } catch (std::exception& e) {
55846       {
55847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55848       };
55849     } catch (Dali::DaliException e) {
55850       {
55851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55852       };
55853     } catch (...) {
55854       {
55855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55856       };
55857     }
55858   }
55859
55860   jresult = (unsigned long)result;
55861   return jresult;
55862 }
55863
55864
55865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55866   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55867   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
55868
55869   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55870   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
55871   {
55872     try {
55873       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55874     } catch (std::out_of_range& e) {
55875       {
55876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55877       };
55878     } catch (std::exception& e) {
55879       {
55880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55881       };
55882     } catch (Dali::DaliException e) {
55883       {
55884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55885       };
55886     } catch (...) {
55887       {
55888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55889       };
55890     }
55891   }
55892
55893 }
55894
55895
55896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55897   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55898   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
55899
55900   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55901   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
55902   {
55903     try {
55904       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55905     } catch (std::out_of_range& e) {
55906       {
55907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55908       };
55909     } catch (std::exception& e) {
55910       {
55911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55912       };
55913     } catch (Dali::DaliException e) {
55914       {
55915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55916       };
55917     } catch (...) {
55918       {
55919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55920       };
55921     }
55922   }
55923
55924 }
55925
55926
55927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55928   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
55929   Dali::Actor arg2 ;
55930   Dali::TapGesture *arg3 = 0 ;
55931   Dali::Actor *argp2 ;
55932
55933   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
55934   argp2 = (Dali::Actor *)jarg2;
55935   if (!argp2) {
55936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55937     return ;
55938   }
55939   arg2 = *argp2;
55940   arg3 = (Dali::TapGesture *)jarg3;
55941   if (!arg3) {
55942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
55943     return ;
55944   }
55945   {
55946     try {
55947       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
55948     } catch (std::out_of_range& e) {
55949       {
55950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55951       };
55952     } catch (std::exception& e) {
55953       {
55954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55955       };
55956     } catch (Dali::DaliException e) {
55957       {
55958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55959       };
55960     } catch (...) {
55961       {
55962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55963       };
55964     }
55965   }
55966
55967 }
55968
55969
55970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
55971   void * jresult ;
55972   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
55973
55974   {
55975     try {
55976       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
55977     } catch (std::out_of_range& e) {
55978       {
55979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55980       };
55981     } catch (std::exception& e) {
55982       {
55983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55984       };
55985     } catch (Dali::DaliException e) {
55986       {
55987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55988       };
55989     } catch (...) {
55990       {
55991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55992       };
55993     }
55994   }
55995
55996   jresult = (void *)result;
55997   return jresult;
55998 }
55999
56000
56001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
56002   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
56003
56004   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
56005   {
56006     try {
56007       delete arg1;
56008     } catch (std::out_of_range& e) {
56009       {
56010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56011       };
56012     } catch (std::exception& e) {
56013       {
56014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56015       };
56016     } catch (Dali::DaliException e) {
56017       {
56018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56019       };
56020     } catch (...) {
56021       {
56022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56023       };
56024     }
56025   }
56026
56027 }
56028
56029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
56030   unsigned int jresult ;
56031   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56032   bool result;
56033
56034   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56035   {
56036     try {
56037       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
56038     } catch (std::out_of_range& e) {
56039       {
56040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56041       };
56042     } catch (std::exception& e) {
56043       {
56044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56045       };
56046     } catch (Dali::DaliException e) {
56047       {
56048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56049       };
56050     } catch (...) {
56051       {
56052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56053       };
56054     }
56055   }
56056
56057   jresult = result;
56058   return jresult;
56059 }
56060
56061
56062 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
56063   unsigned long jresult ;
56064   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56065   std::size_t result;
56066
56067   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56068   {
56069     try {
56070       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
56071     } catch (std::out_of_range& e) {
56072       {
56073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56074       };
56075     } catch (std::exception& e) {
56076       {
56077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56078       };
56079     } catch (Dali::DaliException e) {
56080       {
56081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56082       };
56083     } catch (...) {
56084       {
56085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56086       };
56087     }
56088   }
56089
56090   jresult = (unsigned long)result;
56091   return jresult;
56092 }
56093
56094
56095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
56096   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56097   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
56098
56099   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56100   arg2 = (void (*)(Dali::ResourceImage))jarg2;
56101   {
56102     try {
56103       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
56104     } catch (std::out_of_range& e) {
56105       {
56106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56107       };
56108     } catch (std::exception& e) {
56109       {
56110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56111       };
56112     } catch (Dali::DaliException e) {
56113       {
56114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56115       };
56116     } catch (...) {
56117       {
56118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56119       };
56120     }
56121   }
56122
56123 }
56124
56125
56126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
56127   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56128   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
56129
56130   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56131   arg2 = (void (*)(Dali::ResourceImage))jarg2;
56132   {
56133     try {
56134       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
56135     } catch (std::out_of_range& e) {
56136       {
56137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56138       };
56139     } catch (std::exception& e) {
56140       {
56141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56142       };
56143     } catch (Dali::DaliException e) {
56144       {
56145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56146       };
56147     } catch (...) {
56148       {
56149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56150       };
56151     }
56152   }
56153
56154 }
56155
56156
56157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
56158   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56159   Dali::ResourceImage arg2 ;
56160   Dali::ResourceImage *argp2 ;
56161
56162   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56163   argp2 = (Dali::ResourceImage *)jarg2;
56164   if (!argp2) {
56165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
56166     return ;
56167   }
56168   arg2 = *argp2;
56169   {
56170     try {
56171       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
56172     } catch (std::out_of_range& e) {
56173       {
56174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56175       };
56176     } catch (std::exception& e) {
56177       {
56178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56179       };
56180     } catch (Dali::DaliException e) {
56181       {
56182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56183       };
56184     } catch (...) {
56185       {
56186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56187       };
56188     }
56189   }
56190
56191 }
56192
56193
56194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
56195   void * jresult ;
56196   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
56197
56198   {
56199     try {
56200       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
56201     } catch (std::out_of_range& e) {
56202       {
56203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56204       };
56205     } catch (std::exception& e) {
56206       {
56207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56208       };
56209     } catch (Dali::DaliException e) {
56210       {
56211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56212       };
56213     } catch (...) {
56214       {
56215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56216       };
56217     }
56218   }
56219
56220   jresult = (void *)result;
56221   return jresult;
56222 }
56223
56224
56225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
56226   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56227
56228   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56229   {
56230     try {
56231       delete arg1;
56232     } catch (std::out_of_range& e) {
56233       {
56234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56235       };
56236     } catch (std::exception& e) {
56237       {
56238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56239       };
56240     } catch (Dali::DaliException e) {
56241       {
56242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56243       };
56244     } catch (...) {
56245       {
56246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56247       };
56248     }
56249   }
56250
56251 }
56252
56253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
56254   unsigned int jresult ;
56255   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56256   bool result = false;
56257
56258   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56259   {
56260     try {
56261       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);
56262     } catch (std::out_of_range& e) {
56263       {
56264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56265       };
56266     } catch (std::exception& e) {
56267       {
56268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56269       };
56270     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56271   }
56272   jresult = result;
56273   return jresult;
56274 }
56275
56276 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
56277   unsigned long jresult ;
56278   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56279   std::size_t result = 0;
56280
56281   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56282   {
56283     try {
56284       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);
56285     } catch (std::out_of_range& e) {
56286       {
56287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56288       };
56289     } catch (std::exception& e) {
56290       {
56291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56292       };
56293     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56294   }
56295   jresult = (unsigned long)result;
56296   return jresult;
56297 }
56298
56299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
56300   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56301   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
56302
56303   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56304   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
56305   {
56306     try {
56307       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
56308     } catch (std::out_of_range& e) {
56309       {
56310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56311       };
56312     } catch (std::exception& e) {
56313       {
56314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56315       };
56316     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56317   }
56318 }
56319
56320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
56321   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56322   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
56323
56324   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56325   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
56326   {
56327     try {
56328       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
56329     } catch (std::out_of_range& e) {
56330       {
56331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56332       };
56333     } catch (std::exception& e) {
56334       {
56335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56336       };
56337     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56338   }
56339 }
56340
56341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
56342   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56343   Dali::Actor arg2 ;
56344   //bool arg3 ;
56345   Dali::LayoutDirection::Type arg4 ;
56346   Dali::Actor *argp2 ;
56347
56348   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56349   argp2 = (Dali::Actor *)jarg2;
56350   if (!argp2) {
56351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56352     return ;
56353   }
56354   arg2 = *argp2;
56355   //arg3 = jarg3 ? true : false;
56356   arg4 = (Dali::LayoutDirection::Type)jarg4;
56357   {
56358     try {
56359       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
56360     } catch (std::out_of_range& e) {
56361       {
56362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56363       };
56364     } catch (std::exception& e) {
56365       {
56366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56367       };
56368     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56369   }
56370 }
56371
56372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
56373   void * jresult ;
56374   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
56375
56376   {
56377     try {
56378       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
56379     } catch (std::out_of_range& e) {
56380       {
56381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56382       };
56383     } catch (std::exception& e) {
56384       {
56385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56386       };
56387     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56388   }
56389   jresult = (void *)result;
56390   return jresult;
56391 }
56392
56393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
56394   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56395
56396   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56397   {
56398     try {
56399       delete arg1;
56400     } catch (std::out_of_range& e) {
56401       {
56402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56403       };
56404     } catch (std::exception& e) {
56405       {
56406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56407       };
56408     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56409   }
56410 }
56411
56412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
56413   unsigned int jresult ;
56414   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
56415   bool result;
56416
56417   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
56418   {
56419     try {
56420       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);
56421     } catch (std::out_of_range& e) {
56422       {
56423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56424       };
56425     } catch (std::exception& e) {
56426       {
56427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56428       };
56429     } catch (Dali::DaliException e) {
56430       {
56431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56432       };
56433     } catch (...) {
56434       {
56435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56436       };
56437     }
56438   }
56439
56440   jresult = result;
56441   return jresult;
56442 }
56443
56444
56445 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
56446   unsigned long jresult ;
56447   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
56448   std::size_t result;
56449
56450   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
56451   {
56452     try {
56453       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);
56454     } catch (std::out_of_range& e) {
56455       {
56456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56457       };
56458     } catch (std::exception& e) {
56459       {
56460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56461       };
56462     } catch (Dali::DaliException e) {
56463       {
56464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56465       };
56466     } catch (...) {
56467       {
56468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56469       };
56470     }
56471   }
56472
56473   jresult = (unsigned long)result;
56474   return jresult;
56475 }
56476
56477
56478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
56479   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
56480   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
56481
56482   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
56483   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
56484   {
56485     try {
56486       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
56487     } catch (std::out_of_range& e) {
56488       {
56489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56490       };
56491     } catch (std::exception& e) {
56492       {
56493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56494       };
56495     } catch (Dali::DaliException e) {
56496       {
56497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56498       };
56499     } catch (...) {
56500       {
56501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56502       };
56503     }
56504   }
56505
56506 }
56507
56508
56509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
56510   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
56511   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
56512
56513   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
56514   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
56515   {
56516     try {
56517       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
56518     } catch (std::out_of_range& e) {
56519       {
56520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56521       };
56522     } catch (std::exception& e) {
56523       {
56524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56525       };
56526     } catch (Dali::DaliException e) {
56527       {
56528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56529       };
56530     } catch (...) {
56531       {
56532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56533       };
56534     }
56535   }
56536
56537 }
56538
56539
56540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
56541   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
56542   Dali::Actor arg2 ;
56543   bool arg3 ;
56544   Dali::DevelActor::VisibilityChange::Type arg4 ;
56545   Dali::Actor *argp2 ;
56546
56547   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
56548   argp2 = (Dali::Actor *)jarg2;
56549   if (!argp2) {
56550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56551     return ;
56552   }
56553   arg2 = *argp2;
56554   arg3 = jarg3 ? true : false;
56555   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
56556   {
56557     try {
56558       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
56559     } catch (std::out_of_range& e) {
56560       {
56561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56562       };
56563     } catch (std::exception& e) {
56564       {
56565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56566       };
56567     } catch (Dali::DaliException e) {
56568       {
56569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56570       };
56571     } catch (...) {
56572       {
56573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56574       };
56575     }
56576   }
56577
56578 }
56579
56580
56581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
56582   void * jresult ;
56583   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
56584
56585   {
56586     try {
56587       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
56588     } catch (std::out_of_range& e) {
56589       {
56590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56591       };
56592     } catch (std::exception& e) {
56593       {
56594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56595       };
56596     } catch (Dali::DaliException e) {
56597       {
56598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56599       };
56600     } catch (...) {
56601       {
56602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56603       };
56604     }
56605   }
56606
56607   jresult = (void *)result;
56608   return jresult;
56609 }
56610
56611
56612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
56613   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
56614
56615   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
56616   {
56617     try {
56618       delete arg1;
56619     } catch (std::out_of_range& e) {
56620       {
56621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56622       };
56623     } catch (std::exception& e) {
56624       {
56625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56626       };
56627     } catch (Dali::DaliException e) {
56628       {
56629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56630       };
56631     } catch (...) {
56632       {
56633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56634       };
56635     }
56636   }
56637
56638 }
56639
56640
56641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
56642   void * jresult ;
56643   Dali::Timer *result = 0 ;
56644
56645   {
56646     try {
56647       result = (Dali::Timer *)new Dali::Timer();
56648     } catch (std::out_of_range& e) {
56649       {
56650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56651       };
56652     } catch (std::exception& e) {
56653       {
56654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56655       };
56656     } catch (Dali::DaliException e) {
56657       {
56658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56659       };
56660     } catch (...) {
56661       {
56662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56663       };
56664     }
56665   }
56666
56667   jresult = (void *)result;
56668   return jresult;
56669 }
56670
56671
56672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
56673   void * jresult ;
56674   unsigned int arg1 ;
56675   Dali::Timer result;
56676
56677   arg1 = (unsigned int)jarg1;
56678   {
56679     try {
56680       result = Dali::Timer::New(arg1);
56681     } catch (std::out_of_range& e) {
56682       {
56683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56684       };
56685     } catch (std::exception& e) {
56686       {
56687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56688       };
56689     } catch (Dali::DaliException e) {
56690       {
56691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56692       };
56693     } catch (...) {
56694       {
56695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56696       };
56697     }
56698   }
56699
56700   jresult = new Dali::Timer((const Dali::Timer &)result);
56701   return jresult;
56702 }
56703
56704
56705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
56706   void * jresult ;
56707   Dali::Timer *arg1 = 0 ;
56708   Dali::Timer *result = 0 ;
56709
56710   arg1 = (Dali::Timer *)jarg1;
56711   if (!arg1) {
56712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
56713     return 0;
56714   }
56715   {
56716     try {
56717       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
56718     } catch (std::out_of_range& e) {
56719       {
56720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56721       };
56722     } catch (std::exception& e) {
56723       {
56724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56725       };
56726     } catch (Dali::DaliException e) {
56727       {
56728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56729       };
56730     } catch (...) {
56731       {
56732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56733       };
56734     }
56735   }
56736
56737   jresult = (void *)result;
56738   return jresult;
56739 }
56740
56741
56742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
56743   void * jresult ;
56744   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56745   Dali::Timer *arg2 = 0 ;
56746   Dali::Timer *result = 0 ;
56747
56748   arg1 = (Dali::Timer *)jarg1;
56749   arg2 = (Dali::Timer *)jarg2;
56750   if (!arg2) {
56751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
56752     return 0;
56753   }
56754   {
56755     try {
56756       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
56757     } catch (std::out_of_range& e) {
56758       {
56759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56760       };
56761     } catch (std::exception& e) {
56762       {
56763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56764       };
56765     } catch (Dali::DaliException e) {
56766       {
56767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56768       };
56769     } catch (...) {
56770       {
56771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56772       };
56773     }
56774   }
56775
56776   jresult = (void *)result;
56777   return jresult;
56778 }
56779
56780
56781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
56782   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56783
56784   arg1 = (Dali::Timer *)jarg1;
56785   {
56786     try {
56787       delete arg1;
56788     } catch (std::out_of_range& e) {
56789       {
56790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56791       };
56792     } catch (std::exception& e) {
56793       {
56794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56795       };
56796     } catch (Dali::DaliException e) {
56797       {
56798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56799       };
56800     } catch (...) {
56801       {
56802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56803       };
56804     }
56805   }
56806
56807 }
56808
56809
56810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
56811   void * jresult ;
56812   Dali::BaseHandle arg1 ;
56813   Dali::BaseHandle *argp1 ;
56814   Dali::Timer result;
56815
56816   argp1 = (Dali::BaseHandle *)jarg1;
56817   if (!argp1) {
56818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
56819     return 0;
56820   }
56821   arg1 = *argp1;
56822   {
56823     try {
56824       result = Dali::Timer::DownCast(arg1);
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 = new Dali::Timer((const Dali::Timer &)result);
56845   return jresult;
56846 }
56847
56848
56849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
56850   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56851
56852   arg1 = (Dali::Timer *)jarg1;
56853   {
56854     try {
56855       (arg1)->Start();
56856     } catch (std::out_of_range& e) {
56857       {
56858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56859       };
56860     } catch (std::exception& e) {
56861       {
56862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56863       };
56864     } catch (Dali::DaliException e) {
56865       {
56866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56867       };
56868     } catch (...) {
56869       {
56870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56871       };
56872     }
56873   }
56874
56875 }
56876
56877
56878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
56879   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56880
56881   arg1 = (Dali::Timer *)jarg1;
56882   {
56883     try {
56884       (arg1)->Stop();
56885     } catch (std::out_of_range& e) {
56886       {
56887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56888       };
56889     } catch (std::exception& e) {
56890       {
56891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56892       };
56893     } catch (Dali::DaliException e) {
56894       {
56895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56896       };
56897     } catch (...) {
56898       {
56899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56900       };
56901     }
56902   }
56903
56904 }
56905
56906
56907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
56908   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56909   unsigned int arg2 ;
56910
56911   arg1 = (Dali::Timer *)jarg1;
56912   arg2 = (unsigned int)jarg2;
56913   {
56914     try {
56915       (arg1)->SetInterval(arg2);
56916     } catch (std::out_of_range& e) {
56917       {
56918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56919       };
56920     } catch (std::exception& e) {
56921       {
56922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56923       };
56924     } catch (Dali::DaliException e) {
56925       {
56926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56927       };
56928     } catch (...) {
56929       {
56930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56931       };
56932     }
56933   }
56934
56935 }
56936
56937
56938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
56939   unsigned int jresult ;
56940   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56941   unsigned int result;
56942
56943   arg1 = (Dali::Timer *)jarg1;
56944   {
56945     try {
56946       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
56947     } catch (std::out_of_range& e) {
56948       {
56949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56950       };
56951     } catch (std::exception& e) {
56952       {
56953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56954       };
56955     } catch (Dali::DaliException e) {
56956       {
56957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56958       };
56959     } catch (...) {
56960       {
56961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56962       };
56963     }
56964   }
56965
56966   jresult = result;
56967   return jresult;
56968 }
56969
56970
56971 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
56972   unsigned int jresult ;
56973   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
56974   bool result;
56975
56976   arg1 = (Dali::Timer *)jarg1;
56977   {
56978     try {
56979       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
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 = result;
57000   return jresult;
57001 }
57002
57003
57004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
57005   void * jresult ;
57006   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
57007   Dali::Timer::TimerSignalType *result = 0 ;
57008
57009   arg1 = (Dali::Timer *)jarg1;
57010   {
57011     try {
57012       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
57013     } catch (std::out_of_range& e) {
57014       {
57015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57016       };
57017     } catch (std::exception& e) {
57018       {
57019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57020       };
57021     } catch (Dali::DaliException e) {
57022       {
57023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57024       };
57025     } catch (...) {
57026       {
57027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57028       };
57029     }
57030   }
57031
57032   jresult = (void *)result;
57033   return jresult;
57034 }
57035
57036
57037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
57038   unsigned int jresult ;
57039   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57040   bool result;
57041
57042   arg1 = (Dali::Signal< bool () > *)jarg1;
57043   {
57044     try {
57045       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
57046     } catch (std::out_of_range& e) {
57047       {
57048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57049       };
57050     } catch (std::exception& e) {
57051       {
57052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57053       };
57054     } catch (Dali::DaliException e) {
57055       {
57056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57057       };
57058     } catch (...) {
57059       {
57060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57061       };
57062     }
57063   }
57064
57065   jresult = result;
57066   return jresult;
57067 }
57068
57069
57070 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
57071   unsigned long jresult ;
57072   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57073   std::size_t result;
57074
57075   arg1 = (Dali::Signal< bool () > *)jarg1;
57076   {
57077     try {
57078       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
57079     } catch (std::out_of_range& e) {
57080       {
57081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57082       };
57083     } catch (std::exception& e) {
57084       {
57085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57086       };
57087     } catch (Dali::DaliException e) {
57088       {
57089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57090       };
57091     } catch (...) {
57092       {
57093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57094       };
57095     }
57096   }
57097
57098   jresult = (unsigned long)result;
57099   return jresult;
57100 }
57101
57102
57103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
57104   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57105   bool (*arg2)() = (bool (*)()) 0 ;
57106
57107   arg1 = (Dali::Signal< bool () > *)jarg1;
57108   arg2 = (bool (*)())jarg2;
57109   {
57110     try {
57111       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
57112     } catch (std::out_of_range& e) {
57113       {
57114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57115       };
57116     } catch (std::exception& e) {
57117       {
57118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57119       };
57120     } catch (Dali::DaliException e) {
57121       {
57122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57123       };
57124     } catch (...) {
57125       {
57126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57127       };
57128     }
57129   }
57130
57131 }
57132
57133
57134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
57135   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57136   bool (*arg2)() = (bool (*)()) 0 ;
57137
57138   arg1 = (Dali::Signal< bool () > *)jarg1;
57139   arg2 = (bool (*)())jarg2;
57140   {
57141     try {
57142       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
57143     } catch (std::out_of_range& e) {
57144       {
57145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57146       };
57147     } catch (std::exception& e) {
57148       {
57149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57150       };
57151     } catch (Dali::DaliException e) {
57152       {
57153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57154       };
57155     } catch (...) {
57156       {
57157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57158       };
57159     }
57160   }
57161
57162 }
57163
57164
57165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
57166   unsigned int jresult ;
57167   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57168   bool result;
57169
57170   arg1 = (Dali::Signal< bool () > *)jarg1;
57171   {
57172     try {
57173       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
57174     } catch (std::out_of_range& e) {
57175       {
57176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57177       };
57178     } catch (std::exception& e) {
57179       {
57180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57181       };
57182     } catch (Dali::DaliException e) {
57183       {
57184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57185       };
57186     } catch (...) {
57187       {
57188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57189       };
57190     }
57191   }
57192
57193   jresult = result;
57194   return jresult;
57195 }
57196
57197
57198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
57199   void * jresult ;
57200   Dali::Signal< bool () > *result = 0 ;
57201
57202   {
57203     try {
57204       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
57205     } catch (std::out_of_range& e) {
57206       {
57207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57208       };
57209     } catch (std::exception& e) {
57210       {
57211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57212       };
57213     } catch (Dali::DaliException e) {
57214       {
57215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57216       };
57217     } catch (...) {
57218       {
57219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57220       };
57221     }
57222   }
57223
57224   jresult = (void *)result;
57225   return jresult;
57226 }
57227
57228
57229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
57230   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57231
57232   arg1 = (Dali::Signal< bool () > *)jarg1;
57233   {
57234     try {
57235       delete arg1;
57236     } catch (std::out_of_range& e) {
57237       {
57238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57239       };
57240     } catch (std::exception& e) {
57241       {
57242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57243       };
57244     } catch (Dali::DaliException e) {
57245       {
57246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57247       };
57248     } catch (...) {
57249       {
57250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57251       };
57252     }
57253   }
57254
57255 }
57256
57257
57258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
57259   int jresult ;
57260   int result;
57261
57262   {
57263     try {
57264       result = (int)Dali::Toolkit::Visual::Property::TYPE;
57265     } catch (std::out_of_range& e) {
57266       {
57267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57268       };
57269     } catch (std::exception& e) {
57270       {
57271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57272       };
57273     } catch (Dali::DaliException e) {
57274       {
57275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57276       };
57277     } catch (...) {
57278       {
57279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57280       };
57281     }
57282   }
57283
57284   jresult = (int)result;
57285   return jresult;
57286 }
57287
57288
57289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
57290   int jresult ;
57291   int result;
57292
57293   {
57294     try {
57295       result = (int)Dali::Toolkit::Visual::Property::SHADER;
57296     } catch (std::out_of_range& e) {
57297       {
57298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57299       };
57300     } catch (std::exception& e) {
57301       {
57302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57303       };
57304     } catch (Dali::DaliException e) {
57305       {
57306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57307       };
57308     } catch (...) {
57309       {
57310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57311       };
57312     }
57313   }
57314
57315   jresult = (int)result;
57316   return jresult;
57317 }
57318
57319
57320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
57321   int jresult ;
57322   int result;
57323
57324   {
57325     try {
57326       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
57327     } catch (std::out_of_range& e) {
57328       {
57329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57330       };
57331     } catch (std::exception& e) {
57332       {
57333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57334       };
57335     } catch (Dali::DaliException e) {
57336       {
57337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57338       };
57339     } catch (...) {
57340       {
57341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57342       };
57343     }
57344   }
57345
57346   jresult = (int)result;
57347   return jresult;
57348 }
57349
57350
57351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
57352   int jresult ;
57353   int result;
57354
57355   {
57356     try {
57357       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
57358     } catch (std::out_of_range& e) {
57359       {
57360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57361       };
57362     } catch (std::exception& e) {
57363       {
57364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57365       };
57366     } catch (Dali::DaliException e) {
57367       {
57368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57369       };
57370     } catch (...) {
57371       {
57372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57373       };
57374     }
57375   }
57376
57377   jresult = (int)result;
57378   return jresult;
57379 }
57380
57381
57382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
57383   int jresult ;
57384   int result;
57385
57386   {
57387     try {
57388       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
57389     } catch (std::out_of_range& e) {
57390       {
57391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57392       };
57393     } catch (std::exception& e) {
57394       {
57395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57396       };
57397     } catch (Dali::DaliException e) {
57398       {
57399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57400       };
57401     } catch (...) {
57402       {
57403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57404       };
57405     }
57406   }
57407
57408   jresult = (int)result;
57409   return jresult;
57410 }
57411
57412
57413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
57414   int jresult ;
57415   int result;
57416
57417   {
57418     try {
57419       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
57420     } catch (std::out_of_range& e) {
57421       {
57422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57423       };
57424     } catch (std::exception& e) {
57425       {
57426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57427       };
57428     } catch (Dali::DaliException e) {
57429       {
57430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57431       };
57432     } catch (...) {
57433       {
57434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57435       };
57436     }
57437   }
57438
57439   jresult = (int)result;
57440   return jresult;
57441 }
57442
57443
57444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
57445   int jresult ;
57446   int result;
57447
57448   {
57449     try {
57450       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
57451     } catch (std::out_of_range& e) {
57452       {
57453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57454       };
57455     } catch (std::exception& e) {
57456       {
57457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57458       };
57459     } catch (Dali::DaliException e) {
57460       {
57461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57462       };
57463     } catch (...) {
57464       {
57465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57466       };
57467     }
57468   }
57469
57470   jresult = (int)result;
57471   return jresult;
57472 }
57473
57474
57475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
57476   int jresult ;
57477   int result;
57478
57479   {
57480     try {
57481       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
57482     } catch (std::out_of_range& e) {
57483       {
57484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57485       };
57486     } catch (std::exception& e) {
57487       {
57488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57489       };
57490     } catch (Dali::DaliException e) {
57491       {
57492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57493       };
57494     } catch (...) {
57495       {
57496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57497       };
57498     }
57499   }
57500
57501   jresult = (int)result;
57502   return jresult;
57503 }
57504
57505
57506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
57507   int jresult ;
57508   int result;
57509
57510   {
57511     try {
57512       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
57513     } catch (std::out_of_range& e) {
57514       {
57515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57516       };
57517     } catch (std::exception& e) {
57518       {
57519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57520       };
57521     } catch (Dali::DaliException e) {
57522       {
57523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57524       };
57525     } catch (...) {
57526       {
57527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57528       };
57529     }
57530   }
57531
57532   jresult = (int)result;
57533   return jresult;
57534 }
57535
57536
57537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
57538   int jresult ;
57539   int result;
57540
57541   {
57542     try {
57543       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
57544     } catch (std::out_of_range& e) {
57545       {
57546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57547       };
57548     } catch (std::exception& e) {
57549       {
57550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57551       };
57552     } catch (Dali::DaliException e) {
57553       {
57554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57555       };
57556     } catch (...) {
57557       {
57558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57559       };
57560     }
57561   }
57562
57563   jresult = (int)result;
57564   return jresult;
57565 }
57566
57567
57568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
57569   int jresult ;
57570   int result;
57571
57572   {
57573     try {
57574       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
57575     } catch (std::out_of_range& e) {
57576       {
57577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57578       };
57579     } catch (std::exception& e) {
57580       {
57581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57582       };
57583     } catch (Dali::DaliException e) {
57584       {
57585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57586       };
57587     } catch (...) {
57588       {
57589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57590       };
57591     }
57592   }
57593
57594   jresult = (int)result;
57595   return jresult;
57596 }
57597
57598
57599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
57600   int jresult ;
57601   int result;
57602
57603   {
57604     try {
57605       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
57606     } catch (std::out_of_range& e) {
57607       {
57608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57609       };
57610     } catch (std::exception& e) {
57611       {
57612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57613       };
57614     } catch (Dali::DaliException e) {
57615       {
57616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57617       };
57618     } catch (...) {
57619       {
57620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57621       };
57622     }
57623   }
57624
57625   jresult = (int)result;
57626   return jresult;
57627 }
57628
57629
57630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
57631   int jresult ;
57632   int result;
57633
57634   {
57635     try {
57636       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
57637     } catch (std::out_of_range& e) {
57638       {
57639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57640       };
57641     } catch (std::exception& e) {
57642       {
57643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57644       };
57645     } catch (Dali::DaliException e) {
57646       {
57647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57648       };
57649     } catch (...) {
57650       {
57651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57652       };
57653     }
57654   }
57655
57656   jresult = (int)result;
57657   return jresult;
57658 }
57659
57660
57661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
57662   int jresult ;
57663   int result;
57664
57665   {
57666     try {
57667       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
57668     } catch (std::out_of_range& e) {
57669       {
57670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57671       };
57672     } catch (std::exception& e) {
57673       {
57674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57675       };
57676     } catch (Dali::DaliException e) {
57677       {
57678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57679       };
57680     } catch (...) {
57681       {
57682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57683       };
57684     }
57685   }
57686
57687   jresult = (int)result;
57688   return jresult;
57689 }
57690
57691
57692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
57693   int jresult ;
57694   int result;
57695
57696   {
57697     try {
57698       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
57699     } catch (std::out_of_range& e) {
57700       {
57701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57702       };
57703     } catch (std::exception& e) {
57704       {
57705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57706       };
57707     } catch (Dali::DaliException e) {
57708       {
57709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57710       };
57711     } catch (...) {
57712       {
57713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57714       };
57715     }
57716   }
57717
57718   jresult = (int)result;
57719   return jresult;
57720 }
57721
57722
57723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
57724   int jresult ;
57725   int result;
57726
57727   {
57728     try {
57729       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
57730     } catch (std::out_of_range& e) {
57731       {
57732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57733       };
57734     } catch (std::exception& e) {
57735       {
57736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57737       };
57738     } catch (Dali::DaliException e) {
57739       {
57740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57741       };
57742     } catch (...) {
57743       {
57744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57745       };
57746     }
57747   }
57748
57749   jresult = (int)result;
57750   return jresult;
57751 }
57752
57753
57754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
57755   int jresult ;
57756   int result;
57757
57758   {
57759     try {
57760       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
57761     } catch (std::out_of_range& e) {
57762       {
57763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57764       };
57765     } catch (std::exception& e) {
57766       {
57767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57768       };
57769     } catch (Dali::DaliException e) {
57770       {
57771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57772       };
57773     } catch (...) {
57774       {
57775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57776       };
57777     }
57778   }
57779
57780   jresult = (int)result;
57781   return jresult;
57782 }
57783
57784
57785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
57786   int jresult ;
57787   int result;
57788
57789   {
57790     try {
57791       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
57792     } catch (std::out_of_range& e) {
57793       {
57794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57795       };
57796     } catch (std::exception& e) {
57797       {
57798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57799       };
57800     } catch (Dali::DaliException e) {
57801       {
57802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57803       };
57804     } catch (...) {
57805       {
57806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57807       };
57808     }
57809   }
57810
57811   jresult = (int)result;
57812   return jresult;
57813 }
57814
57815
57816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
57817   int jresult ;
57818   int result;
57819
57820   {
57821     try {
57822       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
57823     } catch (std::out_of_range& e) {
57824       {
57825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57826       };
57827     } catch (std::exception& e) {
57828       {
57829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57830       };
57831     } catch (Dali::DaliException e) {
57832       {
57833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57834       };
57835     } catch (...) {
57836       {
57837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57838       };
57839     }
57840   }
57841
57842   jresult = (int)result;
57843   return jresult;
57844 }
57845
57846
57847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
57848   int jresult ;
57849   int result;
57850
57851   {
57852     try {
57853       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
57854     } catch (std::out_of_range& e) {
57855       {
57856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57857       };
57858     } catch (std::exception& e) {
57859       {
57860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57861       };
57862     } catch (Dali::DaliException e) {
57863       {
57864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57865       };
57866     } catch (...) {
57867       {
57868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57869       };
57870     }
57871   }
57872
57873   jresult = (int)result;
57874   return jresult;
57875 }
57876
57877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
57878   int jresult ;
57879   int result;
57880
57881   {
57882     try {
57883       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
57884     } catch (std::out_of_range& e) {
57885       {
57886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57887       };
57888     } catch (std::exception& e) {
57889       {
57890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57891       };
57892     } catch (Dali::DaliException e) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57895       };
57896     } catch (...) {
57897       {
57898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57899       };
57900     }
57901   }
57902
57903   jresult = (int)result;
57904   return jresult;
57905 }
57906
57907
57908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
57909   int jresult ;
57910   int result;
57911   {
57912     try
57913     {
57914       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
57915     } catch (std::out_of_range& e) {
57916       {
57917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57918       };
57919     } catch (std::exception& e) {
57920       {
57921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57922       };
57923     } catch (Dali::DaliException e) {
57924       {
57925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57926       };
57927     } catch (...) {
57928       {
57929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57930       };
57931     }
57932   }
57933
57934   jresult = (int)result;
57935   return jresult;
57936 }
57937
57938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
57939   int jresult ;
57940   int result;
57941   {
57942     try
57943     {
57944       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
57945     } catch (std::out_of_range& e) {
57946       {
57947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57948       };
57949     } catch (std::exception& e) {
57950       {
57951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57952       };
57953     } catch (Dali::DaliException e) {
57954       {
57955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57956       };
57957     } catch (...) {
57958       {
57959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57960       };
57961     }
57962   }
57963
57964   jresult = (int)result;
57965   return jresult;
57966 }
57967
57968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
57969   int jresult ;
57970   int result;
57971   {
57972     try
57973     {
57974       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
57975     } catch (std::out_of_range& e) {
57976       {
57977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57978       };
57979     } catch (std::exception& e) {
57980       {
57981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57982       };
57983     } catch (Dali::DaliException e) {
57984       {
57985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57986       };
57987     } catch (...) {
57988       {
57989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57990       };
57991     }
57992   }
57993
57994   jresult = (int)result;
57995   return jresult;
57996 }
57997
57998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
57999   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
58000 }
58001
58002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
58003   int jresult ;
58004   int result;
58005   {
58006     try
58007     {
58008       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
58009     } catch (std::out_of_range& e) {
58010       {
58011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58012       };
58013     } catch (std::exception& e) {
58014       {
58015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58016       };
58017     } catch (Dali::DaliException e) {
58018       {
58019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58020       };
58021     } catch (...) {
58022       {
58023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58024       };
58025     }
58026   }
58027
58028   jresult = (int)result;
58029   return jresult;
58030 }
58031
58032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
58033   int jresult ;
58034   int result;
58035   {
58036     try
58037     {
58038       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
58039     } catch (std::out_of_range& e) {
58040       {
58041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58042       };
58043     } catch (std::exception& e) {
58044       {
58045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58046       };
58047     } catch (Dali::DaliException e) {
58048       {
58049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58050       };
58051     } catch (...) {
58052       {
58053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58054       };
58055     }
58056   }
58057
58058   jresult = (int)result;
58059   return jresult;
58060 }
58061
58062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
58063   int jresult ;
58064   int result;
58065
58066   {
58067     try {
58068       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
58069     } catch (std::out_of_range& e) {
58070       {
58071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58072       };
58073     } catch (std::exception& e) {
58074       {
58075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58076       };
58077     } catch (Dali::DaliException e) {
58078       {
58079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58080       };
58081     } catch (...) {
58082       {
58083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58084       };
58085     }
58086   }
58087
58088   jresult = (int)result;
58089   return jresult;
58090 }
58091
58092
58093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
58094   int jresult ;
58095   int result;
58096
58097   {
58098     try {
58099       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
58100     } catch (std::out_of_range& e) {
58101       {
58102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58103       };
58104     } catch (std::exception& e) {
58105       {
58106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58107       };
58108     } catch (Dali::DaliException e) {
58109       {
58110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58111       };
58112     } catch (...) {
58113       {
58114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58115       };
58116     }
58117   }
58118
58119   jresult = (int)result;
58120   return jresult;
58121 }
58122
58123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
58124   int jresult ;
58125   int result;
58126   {
58127     try
58128     {
58129       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
58130     } catch (std::out_of_range& e) {
58131       {
58132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58133       };
58134     } catch (std::exception& e) {
58135       {
58136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58137       };
58138     } catch (...) {
58139       {
58140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58141       };
58142     }
58143   }
58144   jresult = (int)result;
58145   return jresult;
58146 }
58147
58148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
58149   int jresult ;
58150   int result;
58151   {
58152     try
58153     {
58154       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
58155     } catch (std::out_of_range& e) {
58156       {
58157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58158       };
58159     } catch (std::exception& e) {
58160       {
58161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58162       };
58163     } catch (...) {
58164       {
58165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58166       };
58167     }
58168   }
58169   jresult = (int)result;
58170   return jresult;
58171 }
58172
58173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
58174   int jresult ;
58175   int result;
58176   {
58177     try
58178     {
58179       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
58180     } catch (std::out_of_range& e) {
58181       {
58182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58183       };
58184     } catch (std::exception& e) {
58185       {
58186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58187       };
58188     } catch (...) {
58189       {
58190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58191       };
58192     }
58193   }
58194   jresult = (int)result;
58195   return jresult;
58196 }
58197
58198
58199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
58200   int jresult ;
58201   int result;
58202   {
58203     try
58204     {
58205       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
58206     } catch (std::out_of_range& e) {
58207       {
58208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58209       };
58210     } catch (std::exception& e) {
58211       {
58212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58213       };
58214     } catch (...) {
58215       {
58216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58217       };
58218     }
58219   }
58220   jresult = (int)result;
58221   return jresult;
58222 }
58223
58224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
58225   int jresult ;
58226   int result;
58227   {
58228     try
58229     {
58230       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
58231     } catch (std::out_of_range& e) {
58232       {
58233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58234       };
58235     } catch (std::exception& e) {
58236       {
58237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58238       };
58239     } catch (...) {
58240       {
58241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58242       };
58243     }
58244   }
58245   jresult = (int)result;
58246   return jresult;
58247 }
58248
58249
58250
58251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
58252   int jresult ;
58253   int result;
58254
58255   {
58256     try {
58257       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
58258     } catch (std::out_of_range& e) {
58259       {
58260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58261       };
58262     } catch (std::exception& e) {
58263       {
58264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58265       };
58266     } catch (Dali::DaliException e) {
58267       {
58268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58269       };
58270     } catch (...) {
58271       {
58272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58273       };
58274     }
58275   }
58276
58277   jresult = (int)result;
58278   return jresult;
58279 }
58280
58281
58282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
58283   int jresult ;
58284   int result;
58285
58286   {
58287     try {
58288       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
58289     } catch (std::out_of_range& e) {
58290       {
58291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58292       };
58293     } catch (std::exception& e) {
58294       {
58295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58296       };
58297     } catch (Dali::DaliException e) {
58298       {
58299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58300       };
58301     } catch (...) {
58302       {
58303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58304       };
58305     }
58306   }
58307
58308   jresult = (int)result;
58309   return jresult;
58310 }
58311
58312
58313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
58314   int jresult ;
58315   int result;
58316
58317   {
58318     try {
58319       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
58320     } catch (std::out_of_range& e) {
58321       {
58322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58323       };
58324     } catch (std::exception& e) {
58325       {
58326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58327       };
58328     } catch (Dali::DaliException e) {
58329       {
58330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58331       };
58332     } catch (...) {
58333       {
58334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58335       };
58336     }
58337   }
58338
58339   jresult = (int)result;
58340   return jresult;
58341 }
58342
58343
58344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
58345   int jresult ;
58346   int result;
58347
58348   {
58349     try {
58350       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
58351     } catch (std::out_of_range& e) {
58352       {
58353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58354       };
58355     } catch (std::exception& e) {
58356       {
58357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58358       };
58359     } catch (Dali::DaliException e) {
58360       {
58361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58362       };
58363     } catch (...) {
58364       {
58365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58366       };
58367     }
58368   }
58369
58370   jresult = (int)result;
58371   return jresult;
58372 }
58373
58374
58375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
58376   int jresult ;
58377   int result;
58378
58379   {
58380     try {
58381       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
58382     } catch (std::out_of_range& e) {
58383       {
58384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58385       };
58386     } catch (std::exception& e) {
58387       {
58388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58389       };
58390     } catch (Dali::DaliException e) {
58391       {
58392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58393       };
58394     } catch (...) {
58395       {
58396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58397       };
58398     }
58399   }
58400
58401   jresult = (int)result;
58402   return jresult;
58403 }
58404
58405
58406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
58407   int jresult ;
58408   int result;
58409
58410   {
58411     try {
58412       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
58413     } catch (std::out_of_range& e) {
58414       {
58415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58416       };
58417     } catch (std::exception& e) {
58418       {
58419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58420       };
58421     } catch (Dali::DaliException e) {
58422       {
58423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58424       };
58425     } catch (...) {
58426       {
58427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58428       };
58429     }
58430   }
58431
58432   jresult = (int)result;
58433   return jresult;
58434 }
58435
58436
58437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
58438   int jresult ;
58439   int result;
58440
58441   {
58442     try {
58443       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
58444     } catch (std::out_of_range& e) {
58445       {
58446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58447       };
58448     } catch (std::exception& e) {
58449       {
58450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58451       };
58452     } catch (Dali::DaliException e) {
58453       {
58454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58455       };
58456     } catch (...) {
58457       {
58458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58459       };
58460     }
58461   }
58462
58463   jresult = (int)result;
58464   return jresult;
58465 }
58466
58467 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
58468   int jresult ;
58469   int result;
58470
58471   {
58472     try {
58473       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
58474     } catch (std::out_of_range& e) {
58475       {
58476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58477       };
58478     } catch (std::exception& e) {
58479       {
58480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58481       };
58482     } catch (...) {
58483       {
58484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58485       };
58486     }
58487   }
58488   jresult = (int)result;
58489   return jresult;
58490 }
58491
58492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
58493   int jresult ;
58494   int result;
58495
58496   {
58497     try {
58498       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
58499     } catch (std::out_of_range& e) {
58500       {
58501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58502       };
58503     } catch (std::exception& e) {
58504       {
58505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58506       };
58507     } catch (Dali::DaliException e) {
58508       {
58509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58510       };
58511     } catch (...) {
58512       {
58513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58514       };
58515     }
58516   }
58517
58518   jresult = (int)result;
58519   return jresult;
58520 }
58521
58522
58523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
58524   int jresult ;
58525   int result;
58526
58527   {
58528     try {
58529       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
58530     } catch (std::out_of_range& e) {
58531       {
58532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58533       };
58534     } catch (std::exception& e) {
58535       {
58536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58537       };
58538     } catch (Dali::DaliException e) {
58539       {
58540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58541       };
58542     } catch (...) {
58543       {
58544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58545       };
58546     }
58547   }
58548
58549   jresult = (int)result;
58550   return jresult;
58551 }
58552
58553
58554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
58555   int jresult ;
58556   int result;
58557
58558   {
58559     try {
58560       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
58561     } catch (std::out_of_range& e) {
58562       {
58563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58564       };
58565     } catch (std::exception& e) {
58566       {
58567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58568       };
58569     } catch (Dali::DaliException e) {
58570       {
58571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58572       };
58573     } catch (...) {
58574       {
58575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58576       };
58577     }
58578   }
58579
58580   jresult = (int)result;
58581   return jresult;
58582 }
58583
58584
58585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
58586   int jresult ;
58587   int result;
58588
58589   {
58590     try {
58591       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
58592     } catch (std::out_of_range& e) {
58593       {
58594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58595       };
58596     } catch (std::exception& e) {
58597       {
58598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58599       };
58600     } catch (Dali::DaliException e) {
58601       {
58602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58603       };
58604     } catch (...) {
58605       {
58606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58607       };
58608     }
58609   }
58610
58611   jresult = (int)result;
58612   return jresult;
58613 }
58614
58615
58616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
58617   int jresult ;
58618   int result;
58619
58620   {
58621     try {
58622       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
58623     } catch (std::out_of_range& e) {
58624       {
58625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58626       };
58627     } catch (std::exception& e) {
58628       {
58629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58630       };
58631     } catch (Dali::DaliException e) {
58632       {
58633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58634       };
58635     } catch (...) {
58636       {
58637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58638       };
58639     }
58640   }
58641
58642   jresult = (int)result;
58643   return jresult;
58644 }
58645
58646
58647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
58648   int jresult ;
58649   int result;
58650
58651   {
58652     try {
58653       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
58654     } catch (std::out_of_range& e) {
58655       {
58656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58657       };
58658     } catch (std::exception& e) {
58659       {
58660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58661       };
58662     } catch (Dali::DaliException e) {
58663       {
58664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58665       };
58666     } catch (...) {
58667       {
58668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58669       };
58670     }
58671   }
58672
58673   jresult = (int)result;
58674   return jresult;
58675 }
58676
58677
58678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
58679   int jresult ;
58680   int result;
58681
58682   {
58683     try {
58684       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
58685     } catch (std::out_of_range& e) {
58686       {
58687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58688       };
58689     } catch (std::exception& e) {
58690       {
58691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58692       };
58693     } catch (Dali::DaliException e) {
58694       {
58695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58696       };
58697     } catch (...) {
58698       {
58699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58700       };
58701     }
58702   }
58703
58704   jresult = (int)result;
58705   return jresult;
58706 }
58707
58708
58709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
58710   int jresult ;
58711   int result;
58712
58713   {
58714     try {
58715       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
58716     } catch (std::out_of_range& e) {
58717       {
58718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58719       };
58720     } catch (std::exception& e) {
58721       {
58722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58723       };
58724     } catch (Dali::DaliException e) {
58725       {
58726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58727       };
58728     } catch (...) {
58729       {
58730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58731       };
58732     }
58733   }
58734
58735   jresult = (int)result;
58736   return jresult;
58737 }
58738
58739
58740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
58741   int jresult ;
58742   int result;
58743
58744   {
58745     try {
58746       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
58747     } catch (std::out_of_range& e) {
58748       {
58749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58750       };
58751     } catch (std::exception& e) {
58752       {
58753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58754       };
58755     } catch (Dali::DaliException e) {
58756       {
58757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58758       };
58759     } catch (...) {
58760       {
58761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58762       };
58763     }
58764   }
58765
58766   jresult = (int)result;
58767   return jresult;
58768 }
58769
58770
58771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
58772   int jresult ;
58773   int result;
58774
58775   {
58776     try {
58777       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
58778     } catch (std::out_of_range& e) {
58779       {
58780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58781       };
58782     } catch (std::exception& e) {
58783       {
58784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58785       };
58786     } catch (Dali::DaliException e) {
58787       {
58788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58789       };
58790     } catch (...) {
58791       {
58792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58793       };
58794     }
58795   }
58796
58797   jresult = (int)result;
58798   return jresult;
58799 }
58800
58801
58802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
58803   int jresult ;
58804   int result;
58805
58806   {
58807     try {
58808       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
58809     } catch (std::out_of_range& e) {
58810       {
58811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58812       };
58813     } catch (std::exception& e) {
58814       {
58815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58816       };
58817     } catch (Dali::DaliException e) {
58818       {
58819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58820       };
58821     } catch (...) {
58822       {
58823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58824       };
58825     }
58826   }
58827
58828   jresult = (int)result;
58829   return jresult;
58830 }
58831
58832
58833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
58834   int jresult ;
58835   int result;
58836
58837   {
58838     try {
58839       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
58840     } catch (std::out_of_range& e) {
58841       {
58842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58843       };
58844     } catch (std::exception& e) {
58845       {
58846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58847       };
58848     } catch (Dali::DaliException e) {
58849       {
58850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58851       };
58852     } catch (...) {
58853       {
58854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58855       };
58856     }
58857   }
58858
58859   jresult = (int)result;
58860   return jresult;
58861 }
58862
58863
58864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
58865   int jresult ;
58866   int result;
58867
58868   {
58869     try {
58870       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
58871     } catch (std::out_of_range& e) {
58872       {
58873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58874       };
58875     } catch (std::exception& e) {
58876       {
58877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58878       };
58879     } catch (Dali::DaliException e) {
58880       {
58881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58882       };
58883     } catch (...) {
58884       {
58885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58886       };
58887     }
58888   }
58889
58890   jresult = (int)result;
58891   return jresult;
58892 }
58893
58894
58895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
58896   int jresult ;
58897   int result;
58898
58899   {
58900     try {
58901       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
58902     } catch (std::out_of_range& e) {
58903       {
58904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58905       };
58906     } catch (std::exception& e) {
58907       {
58908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58909       };
58910     } catch (Dali::DaliException e) {
58911       {
58912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58913       };
58914     } catch (...) {
58915       {
58916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58917       };
58918     }
58919   }
58920
58921   jresult = (int)result;
58922   return jresult;
58923 }
58924
58925
58926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
58927   int jresult ;
58928   int result;
58929
58930   {
58931     try {
58932       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
58933     } catch (std::out_of_range& e) {
58934       {
58935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58936       };
58937     } catch (std::exception& e) {
58938       {
58939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58940       };
58941     } catch (Dali::DaliException e) {
58942       {
58943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58944       };
58945     } catch (...) {
58946       {
58947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58948       };
58949     }
58950   }
58951
58952   jresult = (int)result;
58953   return jresult;
58954 }
58955
58956
58957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
58958   int jresult ;
58959   int result;
58960
58961   {
58962     try {
58963       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
58964     } catch (std::out_of_range& e) {
58965       {
58966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58967       };
58968     } catch (std::exception& e) {
58969       {
58970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58971       };
58972     } catch (Dali::DaliException e) {
58973       {
58974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58975       };
58976     } catch (...) {
58977       {
58978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58979       };
58980     }
58981   }
58982
58983   jresult = (int)result;
58984   return jresult;
58985 }
58986
58987
58988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
58989   int jresult ;
58990   int result;
58991
58992   {
58993     try {
58994       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
58995     } catch (std::out_of_range& e) {
58996       {
58997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58998       };
58999     } catch (std::exception& e) {
59000       {
59001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59002       };
59003     } catch (Dali::DaliException e) {
59004       {
59005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59006       };
59007     } catch (...) {
59008       {
59009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59010       };
59011     }
59012   }
59013
59014   jresult = (int)result;
59015   return jresult;
59016 }
59017
59018
59019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
59020   int jresult ;
59021   int result;
59022
59023   {
59024     try {
59025       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
59026     } catch (std::out_of_range& e) {
59027       {
59028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59029       };
59030     } catch (std::exception& e) {
59031       {
59032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59033       };
59034     } catch (Dali::DaliException e) {
59035       {
59036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59037       };
59038     } catch (...) {
59039       {
59040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59041       };
59042     }
59043   }
59044
59045   jresult = (int)result;
59046   return jresult;
59047 }
59048
59049
59050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
59051   int jresult ;
59052   int result;
59053
59054   {
59055     try {
59056       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
59057     } catch (std::out_of_range& e) {
59058       {
59059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59060       };
59061     } catch (std::exception& e) {
59062       {
59063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59064       };
59065     } catch (Dali::DaliException e) {
59066       {
59067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59068       };
59069     } catch (...) {
59070       {
59071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59072       };
59073     }
59074   }
59075
59076   jresult = (int)result;
59077   return jresult;
59078 }
59079
59080
59081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
59082   int jresult ;
59083   int result;
59084
59085   {
59086     try {
59087       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
59088     } catch (std::out_of_range& e) {
59089       {
59090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59091       };
59092     } catch (std::exception& e) {
59093       {
59094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59095       };
59096     } catch (Dali::DaliException e) {
59097       {
59098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59099       };
59100     } catch (...) {
59101       {
59102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59103       };
59104     }
59105   }
59106
59107   jresult = (int)result;
59108   return jresult;
59109 }
59110
59111
59112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
59113   int jresult ;
59114   int result;
59115
59116   {
59117     try {
59118       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
59119     } catch (std::out_of_range& e) {
59120       {
59121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59122       };
59123     } catch (std::exception& e) {
59124       {
59125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59126       };
59127     } catch (Dali::DaliException e) {
59128       {
59129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59130       };
59131     } catch (...) {
59132       {
59133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59134       };
59135     }
59136   }
59137
59138   jresult = (int)result;
59139   return jresult;
59140 }
59141
59142
59143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
59144   int jresult ;
59145   int result;
59146
59147   {
59148     try {
59149       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
59150     } catch (std::out_of_range& e) {
59151       {
59152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59153       };
59154     } catch (std::exception& e) {
59155       {
59156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59157       };
59158     } catch (Dali::DaliException e) {
59159       {
59160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59161       };
59162     } catch (...) {
59163       {
59164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59165       };
59166     }
59167   }
59168
59169   jresult = (int)result;
59170   return jresult;
59171 }
59172
59173
59174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
59175   int jresult ;
59176   int result;
59177
59178   {
59179     try {
59180       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
59181     } catch (std::out_of_range& e) {
59182       {
59183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59184       };
59185     } catch (std::exception& e) {
59186       {
59187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59188       };
59189     } catch (Dali::DaliException e) {
59190       {
59191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59192       };
59193     } catch (...) {
59194       {
59195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59196       };
59197     }
59198   }
59199
59200   jresult = (int)result;
59201   return jresult;
59202 }
59203
59204
59205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
59206   int jresult ;
59207   int result;
59208
59209   {
59210     try {
59211       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
59212     } catch (std::out_of_range& e) {
59213       {
59214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59215       };
59216     } catch (std::exception& e) {
59217       {
59218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59219       };
59220     } catch (Dali::DaliException e) {
59221       {
59222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59223       };
59224     } catch (...) {
59225       {
59226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59227       };
59228     }
59229   }
59230
59231   jresult = (int)result;
59232   return jresult;
59233 }
59234
59235
59236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
59237   int jresult ;
59238   int result;
59239
59240   {
59241     try {
59242       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
59243     } catch (std::out_of_range& e) {
59244       {
59245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59246       };
59247     } catch (std::exception& e) {
59248       {
59249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59250       };
59251     } catch (Dali::DaliException e) {
59252       {
59253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59254       };
59255     } catch (...) {
59256       {
59257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59258       };
59259     }
59260   }
59261
59262   jresult = (int)result;
59263   return jresult;
59264 }
59265
59266
59267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
59268   int jresult ;
59269   int result;
59270
59271   {
59272     try {
59273       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
59274     } catch (std::out_of_range& e) {
59275       {
59276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59277       };
59278     } catch (std::exception& e) {
59279       {
59280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59281       };
59282     } catch (Dali::DaliException e) {
59283       {
59284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59285       };
59286     } catch (...) {
59287       {
59288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59289       };
59290     }
59291   }
59292
59293   jresult = (int)result;
59294   return jresult;
59295 }
59296
59297
59298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
59299   int jresult ;
59300   int result;
59301
59302   {
59303     try {
59304       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
59305     } catch (std::out_of_range& e) {
59306       {
59307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59308       };
59309     } catch (std::exception& e) {
59310       {
59311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59312       };
59313     } catch (Dali::DaliException e) {
59314       {
59315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59316       };
59317     } catch (...) {
59318       {
59319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59320       };
59321     }
59322   }
59323
59324   jresult = (int)result;
59325   return jresult;
59326 }
59327
59328
59329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
59330   int jresult ;
59331   int result;
59332
59333   {
59334     try {
59335       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
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 = (int)result;
59356   return jresult;
59357 }
59358
59359
59360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
59361   void * jresult ;
59362   Dali::Toolkit::Builder *result = 0 ;
59363
59364   {
59365     try {
59366       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
59367     } catch (std::out_of_range& e) {
59368       {
59369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59370       };
59371     } catch (std::exception& e) {
59372       {
59373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59374       };
59375     } catch (Dali::DaliException e) {
59376       {
59377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59378       };
59379     } catch (...) {
59380       {
59381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59382       };
59383     }
59384   }
59385
59386   jresult = (void *)result;
59387   return jresult;
59388 }
59389
59390
59391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
59392   void * jresult ;
59393   Dali::Toolkit::Builder result;
59394
59395   {
59396     try {
59397       result = Dali::Toolkit::Builder::New();
59398     } catch (std::out_of_range& e) {
59399       {
59400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59401       };
59402     } catch (std::exception& e) {
59403       {
59404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59405       };
59406     } catch (Dali::DaliException e) {
59407       {
59408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59409       };
59410     } catch (...) {
59411       {
59412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59413       };
59414     }
59415   }
59416
59417   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
59418   return jresult;
59419 }
59420
59421
59422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
59423   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59424
59425   arg1 = (Dali::Toolkit::Builder *)jarg1;
59426   {
59427     try {
59428       delete arg1;
59429     } catch (std::out_of_range& e) {
59430       {
59431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59432       };
59433     } catch (std::exception& e) {
59434       {
59435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59436       };
59437     } catch (Dali::DaliException e) {
59438       {
59439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59440       };
59441     } catch (...) {
59442       {
59443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59444       };
59445     }
59446   }
59447
59448 }
59449
59450
59451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
59452   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59453   std::string *arg2 = 0 ;
59454   Dali::Toolkit::Builder::UIFormat arg3 ;
59455
59456   arg1 = (Dali::Toolkit::Builder *)jarg1;
59457   if (!jarg2) {
59458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59459     return ;
59460   }
59461   std::string arg2_str(jarg2);
59462   arg2 = &arg2_str;
59463   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
59464   {
59465     try {
59466       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
59467     } catch (std::out_of_range& e) {
59468       {
59469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59470       };
59471     } catch (std::exception& e) {
59472       {
59473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59474       };
59475     } catch (Dali::DaliException e) {
59476       {
59477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59478       };
59479     } catch (...) {
59480       {
59481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59482       };
59483     }
59484   }
59485
59486
59487   //argout typemap for const std::string&
59488
59489 }
59490
59491
59492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
59493   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59494   std::string *arg2 = 0 ;
59495
59496   arg1 = (Dali::Toolkit::Builder *)jarg1;
59497   if (!jarg2) {
59498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59499     return ;
59500   }
59501   std::string arg2_str(jarg2);
59502   arg2 = &arg2_str;
59503   {
59504     try {
59505       (arg1)->LoadFromString((std::string const &)*arg2);
59506     } catch (std::out_of_range& e) {
59507       {
59508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59509       };
59510     } catch (std::exception& e) {
59511       {
59512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59513       };
59514     } catch (Dali::DaliException e) {
59515       {
59516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59517       };
59518     } catch (...) {
59519       {
59520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59521       };
59522     }
59523   }
59524
59525
59526   //argout typemap for const std::string&
59527
59528 }
59529
59530
59531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
59532   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59533   Dali::Property::Map *arg2 = 0 ;
59534
59535   arg1 = (Dali::Toolkit::Builder *)jarg1;
59536   arg2 = (Dali::Property::Map *)jarg2;
59537   if (!arg2) {
59538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59539     return ;
59540   }
59541   {
59542     try {
59543       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
59544     } catch (std::out_of_range& e) {
59545       {
59546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59547       };
59548     } catch (std::exception& e) {
59549       {
59550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59551       };
59552     } catch (Dali::DaliException e) {
59553       {
59554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59555       };
59556     } catch (...) {
59557       {
59558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59559       };
59560     }
59561   }
59562
59563 }
59564
59565
59566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
59567   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59568   std::string *arg2 = 0 ;
59569   Dali::Property::Value *arg3 = 0 ;
59570
59571   arg1 = (Dali::Toolkit::Builder *)jarg1;
59572   if (!jarg2) {
59573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59574     return ;
59575   }
59576   std::string arg2_str(jarg2);
59577   arg2 = &arg2_str;
59578   arg3 = (Dali::Property::Value *)jarg3;
59579   if (!arg3) {
59580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
59581     return ;
59582   }
59583   {
59584     try {
59585       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
59586     } catch (std::out_of_range& e) {
59587       {
59588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59589       };
59590     } catch (std::exception& e) {
59591       {
59592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59593       };
59594     } catch (Dali::DaliException e) {
59595       {
59596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59597       };
59598     } catch (...) {
59599       {
59600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59601       };
59602     }
59603   }
59604
59605
59606   //argout typemap for const std::string&
59607
59608 }
59609
59610
59611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
59612   void * jresult ;
59613   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59614   Dali::Property::Map *result = 0 ;
59615
59616   arg1 = (Dali::Toolkit::Builder *)jarg1;
59617   {
59618     try {
59619       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
59620     } catch (std::out_of_range& e) {
59621       {
59622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59623       };
59624     } catch (std::exception& e) {
59625       {
59626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59627       };
59628     } catch (Dali::DaliException e) {
59629       {
59630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59631       };
59632     } catch (...) {
59633       {
59634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59635       };
59636     }
59637   }
59638
59639   jresult = (void *)result;
59640   return jresult;
59641 }
59642
59643
59644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
59645   void * jresult ;
59646   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59647   std::string *arg2 = 0 ;
59648   Dali::Property::Value *result = 0 ;
59649
59650   arg1 = (Dali::Toolkit::Builder *)jarg1;
59651   if (!jarg2) {
59652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59653     return 0;
59654   }
59655   std::string arg2_str(jarg2);
59656   arg2 = &arg2_str;
59657   {
59658     try {
59659       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
59660     } catch (std::out_of_range& e) {
59661       {
59662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59663       };
59664     } catch (std::exception& e) {
59665       {
59666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59667       };
59668     } catch (Dali::DaliException e) {
59669       {
59670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59671       };
59672     } catch (...) {
59673       {
59674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59675       };
59676     }
59677   }
59678
59679   jresult = (void *)result;
59680
59681   //argout typemap for const std::string&
59682
59683   return jresult;
59684 }
59685
59686
59687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
59688   void * jresult ;
59689   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59690   std::string *arg2 = 0 ;
59691   Dali::Animation result;
59692
59693   arg1 = (Dali::Toolkit::Builder *)jarg1;
59694   if (!jarg2) {
59695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59696     return 0;
59697   }
59698   std::string arg2_str(jarg2);
59699   arg2 = &arg2_str;
59700   {
59701     try {
59702       result = (arg1)->CreateAnimation((std::string const &)*arg2);
59703     } catch (std::out_of_range& e) {
59704       {
59705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59706       };
59707     } catch (std::exception& e) {
59708       {
59709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59710       };
59711     } catch (Dali::DaliException e) {
59712       {
59713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59714       };
59715     } catch (...) {
59716       {
59717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59718       };
59719     }
59720   }
59721
59722   jresult = new Dali::Animation((const Dali::Animation &)result);
59723
59724   //argout typemap for const std::string&
59725
59726   return jresult;
59727 }
59728
59729
59730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59731   void * jresult ;
59732   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59733   std::string *arg2 = 0 ;
59734   Dali::Property::Map *arg3 = 0 ;
59735   Dali::Animation result;
59736
59737   arg1 = (Dali::Toolkit::Builder *)jarg1;
59738   if (!jarg2) {
59739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59740     return 0;
59741   }
59742   std::string arg2_str(jarg2);
59743   arg2 = &arg2_str;
59744   arg3 = (Dali::Property::Map *)jarg3;
59745   if (!arg3) {
59746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59747     return 0;
59748   }
59749   {
59750     try {
59751       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
59752     } catch (std::out_of_range& e) {
59753       {
59754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59755       };
59756     } catch (std::exception& e) {
59757       {
59758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59759       };
59760     } catch (Dali::DaliException e) {
59761       {
59762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59763       };
59764     } catch (...) {
59765       {
59766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59767       };
59768     }
59769   }
59770
59771   jresult = new Dali::Animation((const Dali::Animation &)result);
59772
59773   //argout typemap for const std::string&
59774
59775   return jresult;
59776 }
59777
59778
59779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
59780   void * jresult ;
59781   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59782   std::string *arg2 = 0 ;
59783   Dali::Actor arg3 ;
59784   Dali::Actor *argp3 ;
59785   Dali::Animation result;
59786
59787   arg1 = (Dali::Toolkit::Builder *)jarg1;
59788   if (!jarg2) {
59789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59790     return 0;
59791   }
59792   std::string arg2_str(jarg2);
59793   arg2 = &arg2_str;
59794   argp3 = (Dali::Actor *)jarg3;
59795   if (!argp3) {
59796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59797     return 0;
59798   }
59799   arg3 = *argp3;
59800   {
59801     try {
59802       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
59803     } catch (std::out_of_range& e) {
59804       {
59805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59806       };
59807     } catch (std::exception& e) {
59808       {
59809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59810       };
59811     } catch (Dali::DaliException e) {
59812       {
59813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59814       };
59815     } catch (...) {
59816       {
59817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59818       };
59819     }
59820   }
59821
59822   jresult = new Dali::Animation((const Dali::Animation &)result);
59823
59824   //argout typemap for const std::string&
59825
59826   return jresult;
59827 }
59828
59829
59830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
59831   void * jresult ;
59832   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59833   std::string *arg2 = 0 ;
59834   Dali::Property::Map *arg3 = 0 ;
59835   Dali::Actor arg4 ;
59836   Dali::Actor *argp4 ;
59837   Dali::Animation result;
59838
59839   arg1 = (Dali::Toolkit::Builder *)jarg1;
59840   if (!jarg2) {
59841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59842     return 0;
59843   }
59844   std::string arg2_str(jarg2);
59845   arg2 = &arg2_str;
59846   arg3 = (Dali::Property::Map *)jarg3;
59847   if (!arg3) {
59848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59849     return 0;
59850   }
59851   argp4 = (Dali::Actor *)jarg4;
59852   if (!argp4) {
59853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
59854     return 0;
59855   }
59856   arg4 = *argp4;
59857   {
59858     try {
59859       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
59860     } catch (std::out_of_range& e) {
59861       {
59862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59863       };
59864     } catch (std::exception& e) {
59865       {
59866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59867       };
59868     } catch (Dali::DaliException e) {
59869       {
59870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59871       };
59872     } catch (...) {
59873       {
59874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59875       };
59876     }
59877   }
59878
59879   jresult = new Dali::Animation((const Dali::Animation &)result);
59880
59881   //argout typemap for const std::string&
59882
59883   return jresult;
59884 }
59885
59886
59887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
59888   void * jresult ;
59889   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59890   std::string *arg2 = 0 ;
59891   Dali::BaseHandle result;
59892
59893   arg1 = (Dali::Toolkit::Builder *)jarg1;
59894   if (!jarg2) {
59895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59896     return 0;
59897   }
59898   std::string arg2_str(jarg2);
59899   arg2 = &arg2_str;
59900   {
59901     try {
59902       result = (arg1)->Create((std::string const &)*arg2);
59903     } catch (std::out_of_range& e) {
59904       {
59905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59906       };
59907     } catch (std::exception& e) {
59908       {
59909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59910       };
59911     } catch (Dali::DaliException e) {
59912       {
59913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59914       };
59915     } catch (...) {
59916       {
59917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59918       };
59919     }
59920   }
59921
59922   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
59923
59924   //argout typemap for const std::string&
59925
59926   return jresult;
59927 }
59928
59929
59930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
59931   void * jresult ;
59932   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59933   std::string *arg2 = 0 ;
59934   Dali::Property::Map *arg3 = 0 ;
59935   Dali::BaseHandle result;
59936
59937   arg1 = (Dali::Toolkit::Builder *)jarg1;
59938   if (!jarg2) {
59939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59940     return 0;
59941   }
59942   std::string arg2_str(jarg2);
59943   arg2 = &arg2_str;
59944   arg3 = (Dali::Property::Map *)jarg3;
59945   if (!arg3) {
59946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59947     return 0;
59948   }
59949   {
59950     try {
59951       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
59952     } catch (std::out_of_range& e) {
59953       {
59954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59955       };
59956     } catch (std::exception& e) {
59957       {
59958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59959       };
59960     } catch (Dali::DaliException e) {
59961       {
59962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59963       };
59964     } catch (...) {
59965       {
59966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59967       };
59968     }
59969   }
59970
59971   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
59972
59973   //argout typemap for const std::string&
59974
59975   return jresult;
59976 }
59977
59978
59979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
59980   void * jresult ;
59981   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59982   std::string *arg2 = 0 ;
59983   Dali::BaseHandle result;
59984
59985   arg1 = (Dali::Toolkit::Builder *)jarg1;
59986   if (!jarg2) {
59987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59988     return 0;
59989   }
59990   std::string arg2_str(jarg2);
59991   arg2 = &arg2_str;
59992   {
59993     try {
59994       result = (arg1)->CreateFromJson((std::string const &)*arg2);
59995     } catch (std::out_of_range& e) {
59996       {
59997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59998       };
59999     } catch (std::exception& e) {
60000       {
60001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60002       };
60003     } catch (Dali::DaliException e) {
60004       {
60005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60006       };
60007     } catch (...) {
60008       {
60009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60010       };
60011     }
60012   }
60013
60014   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
60015
60016   //argout typemap for const std::string&
60017
60018   return jresult;
60019 }
60020
60021
60022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
60023   unsigned int jresult ;
60024   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60025   std::string *arg2 = 0 ;
60026   Dali::Handle *arg3 = 0 ;
60027   bool result;
60028
60029   arg1 = (Dali::Toolkit::Builder *)jarg1;
60030   if (!jarg2) {
60031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60032     return 0;
60033   }
60034   std::string arg2_str(jarg2);
60035   arg2 = &arg2_str;
60036   arg3 = (Dali::Handle *)jarg3;
60037   if (!arg3) {
60038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
60039     return 0;
60040   }
60041   {
60042     try {
60043       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
60044     } catch (std::out_of_range& e) {
60045       {
60046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60047       };
60048     } catch (std::exception& e) {
60049       {
60050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60051       };
60052     } catch (Dali::DaliException e) {
60053       {
60054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60055       };
60056     } catch (...) {
60057       {
60058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60059       };
60060     }
60061   }
60062
60063   jresult = result;
60064
60065   //argout typemap for const std::string&
60066
60067   return jresult;
60068 }
60069
60070
60071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
60072   unsigned int jresult ;
60073   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60074   Dali::Handle *arg2 = 0 ;
60075   std::string *arg3 = 0 ;
60076   bool result;
60077
60078   arg1 = (Dali::Toolkit::Builder *)jarg1;
60079   arg2 = (Dali::Handle *)jarg2;
60080   if (!arg2) {
60081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
60082     return 0;
60083   }
60084   if (!jarg3) {
60085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60086     return 0;
60087   }
60088   std::string arg3_str(jarg3);
60089   arg3 = &arg3_str;
60090   {
60091     try {
60092       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
60093     } catch (std::out_of_range& e) {
60094       {
60095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60096       };
60097     } catch (std::exception& e) {
60098       {
60099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60100       };
60101     } catch (Dali::DaliException e) {
60102       {
60103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60104       };
60105     } catch (...) {
60106       {
60107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60108       };
60109     }
60110   }
60111
60112   jresult = result;
60113
60114   //argout typemap for const std::string&
60115
60116   return jresult;
60117 }
60118
60119
60120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
60121   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60122   Dali::Actor arg2 ;
60123   Dali::Actor *argp2 ;
60124
60125   arg1 = (Dali::Toolkit::Builder *)jarg1;
60126   argp2 = (Dali::Actor *)jarg2;
60127   if (!argp2) {
60128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60129     return ;
60130   }
60131   arg2 = *argp2;
60132   {
60133     try {
60134       (arg1)->AddActors(arg2);
60135     } catch (std::out_of_range& e) {
60136       {
60137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60138       };
60139     } catch (std::exception& e) {
60140       {
60141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60142       };
60143     } catch (Dali::DaliException e) {
60144       {
60145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60146       };
60147     } catch (...) {
60148       {
60149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60150       };
60151     }
60152   }
60153
60154 }
60155
60156
60157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
60158   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60159   std::string *arg2 = 0 ;
60160   Dali::Actor arg3 ;
60161   Dali::Actor *argp3 ;
60162
60163   arg1 = (Dali::Toolkit::Builder *)jarg1;
60164   if (!jarg2) {
60165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60166     return ;
60167   }
60168   std::string arg2_str(jarg2);
60169   arg2 = &arg2_str;
60170   argp3 = (Dali::Actor *)jarg3;
60171   if (!argp3) {
60172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60173     return ;
60174   }
60175   arg3 = *argp3;
60176   {
60177     try {
60178       (arg1)->AddActors((std::string const &)*arg2,arg3);
60179     } catch (std::out_of_range& e) {
60180       {
60181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60182       };
60183     } catch (std::exception& e) {
60184       {
60185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60186       };
60187     } catch (Dali::DaliException e) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60190       };
60191     } catch (...) {
60192       {
60193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60194       };
60195     }
60196   }
60197
60198
60199   //argout typemap for const std::string&
60200
60201 }
60202
60203
60204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
60205   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60206   std::string *arg2 = 0 ;
60207
60208   arg1 = (Dali::Toolkit::Builder *)jarg1;
60209   if (!jarg2) {
60210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60211     return ;
60212   }
60213   std::string arg2_str(jarg2);
60214   arg2 = &arg2_str;
60215   {
60216     try {
60217       (arg1)->CreateRenderTask((std::string 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   //argout typemap for const std::string&
60239
60240 }
60241
60242
60243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
60244   void * jresult ;
60245   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60246   std::string *arg2 = 0 ;
60247   Dali::Path result;
60248
60249   arg1 = (Dali::Toolkit::Builder *)jarg1;
60250   if (!jarg2) {
60251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60252     return 0;
60253   }
60254   std::string arg2_str(jarg2);
60255   arg2 = &arg2_str;
60256   {
60257     try {
60258       result = (arg1)->GetPath((std::string const &)*arg2);
60259     } catch (std::out_of_range& e) {
60260       {
60261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60262       };
60263     } catch (std::exception& e) {
60264       {
60265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60266       };
60267     } catch (Dali::DaliException e) {
60268       {
60269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60270       };
60271     } catch (...) {
60272       {
60273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60274       };
60275     }
60276   }
60277
60278   jresult = new Dali::Path((const Dali::Path &)result);
60279
60280   //argout typemap for const std::string&
60281
60282   return jresult;
60283 }
60284
60285
60286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
60287   void * jresult ;
60288   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60289   std::string *arg2 = 0 ;
60290   Dali::PathConstrainer result;
60291
60292   arg1 = (Dali::Toolkit::Builder *)jarg1;
60293   if (!jarg2) {
60294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60295     return 0;
60296   }
60297   std::string arg2_str(jarg2);
60298   arg2 = &arg2_str;
60299   {
60300     try {
60301       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
60302     } catch (std::out_of_range& e) {
60303       {
60304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60305       };
60306     } catch (std::exception& e) {
60307       {
60308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60309       };
60310     } catch (Dali::DaliException e) {
60311       {
60312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60313       };
60314     } catch (...) {
60315       {
60316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60317       };
60318     }
60319   }
60320
60321   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
60322
60323   //argout typemap for const std::string&
60324
60325   return jresult;
60326 }
60327
60328
60329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
60330   void * jresult ;
60331   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60332   std::string *arg2 = 0 ;
60333   Dali::LinearConstrainer result;
60334
60335   arg1 = (Dali::Toolkit::Builder *)jarg1;
60336   if (!jarg2) {
60337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60338     return 0;
60339   }
60340   std::string arg2_str(jarg2);
60341   arg2 = &arg2_str;
60342   {
60343     try {
60344       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
60345     } catch (std::out_of_range& e) {
60346       {
60347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60348       };
60349     } catch (std::exception& e) {
60350       {
60351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60352       };
60353     } catch (Dali::DaliException e) {
60354       {
60355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60356       };
60357     } catch (...) {
60358       {
60359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60360       };
60361     }
60362   }
60363
60364   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
60365
60366   //argout typemap for const std::string&
60367
60368   return jresult;
60369 }
60370
60371
60372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
60373   void * jresult ;
60374   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60375   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
60376
60377   arg1 = (Dali::Toolkit::Builder *)jarg1;
60378   {
60379     try {
60380       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
60381     } catch (std::out_of_range& e) {
60382       {
60383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60384       };
60385     } catch (std::exception& e) {
60386       {
60387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60388       };
60389     } catch (Dali::DaliException e) {
60390       {
60391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60392       };
60393     } catch (...) {
60394       {
60395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60396       };
60397     }
60398   }
60399
60400   jresult = (void *)result;
60401   return jresult;
60402 }
60403
60404
60405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
60406   void * jresult ;
60407   Dali::Toolkit::TransitionData *result = 0 ;
60408
60409   {
60410     try {
60411       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
60412     } catch (std::out_of_range& e) {
60413       {
60414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60415       };
60416     } catch (std::exception& e) {
60417       {
60418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60419       };
60420     } catch (Dali::DaliException e) {
60421       {
60422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60423       };
60424     } catch (...) {
60425       {
60426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60427       };
60428     }
60429   }
60430
60431   jresult = (void *)result;
60432   return jresult;
60433 }
60434
60435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
60436   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
60437
60438   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
60439   {
60440     try {
60441       delete arg1;
60442     } catch (std::out_of_range& e) {
60443       {
60444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60445       };
60446     } catch (std::exception& e) {
60447       {
60448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60449       };
60450     } catch (Dali::DaliException e) {
60451       {
60452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60453       };
60454     } catch (...) {
60455       {
60456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60457       };
60458     }
60459   }
60460
60461 }
60462
60463
60464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
60465   void * jresult ;
60466   Dali::Property::Map *arg1 = 0 ;
60467   Dali::Toolkit::TransitionData result;
60468
60469   arg1 = (Dali::Property::Map *)jarg1;
60470   if (!arg1) {
60471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60472     return 0;
60473   }
60474   {
60475     try {
60476       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
60477     } catch (std::out_of_range& e) {
60478       {
60479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60480       };
60481     } catch (std::exception& e) {
60482       {
60483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60484       };
60485     } catch (Dali::DaliException e) {
60486       {
60487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60488       };
60489     } catch (...) {
60490       {
60491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60492       };
60493     }
60494   }
60495
60496   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
60497   return jresult;
60498 }
60499
60500
60501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
60502   void * jresult ;
60503   Dali::Property::Array *arg1 = 0 ;
60504   Dali::Toolkit::TransitionData result;
60505
60506   arg1 = (Dali::Property::Array *)jarg1;
60507   if (!arg1) {
60508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
60509     return 0;
60510   }
60511   {
60512     try {
60513       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
60514     } catch (std::out_of_range& e) {
60515       {
60516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60517       };
60518     } catch (std::exception& e) {
60519       {
60520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60521       };
60522     } catch (Dali::DaliException e) {
60523       {
60524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60525       };
60526     } catch (...) {
60527       {
60528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60529       };
60530     }
60531   }
60532
60533   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
60534   return jresult;
60535 }
60536
60537
60538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
60539   void * jresult ;
60540   Dali::BaseHandle arg1 ;
60541   Dali::BaseHandle *argp1 ;
60542   Dali::Toolkit::TransitionData result;
60543
60544   argp1 = (Dali::BaseHandle *)jarg1;
60545   if (!argp1) {
60546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
60547     return 0;
60548   }
60549   arg1 = *argp1;
60550   {
60551     try {
60552       result = Dali::Toolkit::TransitionData::DownCast(arg1);
60553     } catch (std::out_of_range& e) {
60554       {
60555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60556       };
60557     } catch (std::exception& e) {
60558       {
60559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60560       };
60561     } catch (Dali::DaliException e) {
60562       {
60563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60564       };
60565     } catch (...) {
60566       {
60567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60568       };
60569     }
60570   }
60571
60572   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
60573   return jresult;
60574 }
60575
60576
60577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
60578   void * jresult ;
60579   Dali::Toolkit::TransitionData *arg1 = 0 ;
60580   Dali::Toolkit::TransitionData *result = 0 ;
60581
60582   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
60583   if (!arg1) {
60584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
60585     return 0;
60586   }
60587   {
60588     try {
60589       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
60590     } catch (std::out_of_range& e) {
60591       {
60592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60593       };
60594     } catch (std::exception& e) {
60595       {
60596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60597       };
60598     } catch (Dali::DaliException e) {
60599       {
60600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60601       };
60602     } catch (...) {
60603       {
60604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60605       };
60606     }
60607   }
60608
60609   jresult = (void *)result;
60610   return jresult;
60611 }
60612
60613
60614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
60615   void * jresult ;
60616   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
60617   Dali::Toolkit::TransitionData *arg2 = 0 ;
60618   Dali::Toolkit::TransitionData *result = 0 ;
60619
60620   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
60621   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
60622   if (!arg2) {
60623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
60624     return 0;
60625   }
60626   {
60627     try {
60628       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
60629     } catch (std::out_of_range& e) {
60630       {
60631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60632       };
60633     } catch (std::exception& e) {
60634       {
60635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60636       };
60637     } catch (Dali::DaliException e) {
60638       {
60639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60640       };
60641     } catch (...) {
60642       {
60643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60644       };
60645     }
60646   }
60647
60648   jresult = (void *)result;
60649   return jresult;
60650 }
60651
60652
60653 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
60654   unsigned long jresult ;
60655   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
60656   size_t result;
60657
60658   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
60659   {
60660     try {
60661       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
60662     } catch (std::out_of_range& e) {
60663       {
60664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60665       };
60666     } catch (std::exception& e) {
60667       {
60668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60669       };
60670     } catch (Dali::DaliException e) {
60671       {
60672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60673       };
60674     } catch (...) {
60675       {
60676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60677       };
60678     }
60679   }
60680
60681   jresult = (unsigned long)result;
60682   return jresult;
60683 }
60684
60685
60686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
60687   void * jresult ;
60688   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
60689   size_t arg2 ;
60690   Dali::Property::Map result;
60691
60692   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
60693   arg2 = (size_t)jarg2;
60694   {
60695     try {
60696       result = (arg1)->GetAnimatorAt(arg2);
60697     } catch (std::out_of_range& e) {
60698       {
60699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60700       };
60701     } catch (std::exception& e) {
60702       {
60703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60704       };
60705     } catch (Dali::DaliException e) {
60706       {
60707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60708       };
60709     } catch (...) {
60710       {
60711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60712       };
60713     }
60714   }
60715
60716   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
60717   return jresult;
60718 }
60719
60720
60721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
60722   int jresult ;
60723   int result;
60724
60725   {
60726     try {
60727       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
60728     } catch (std::out_of_range& e) {
60729       {
60730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60731       };
60732     } catch (std::exception& e) {
60733       {
60734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60735       };
60736     } catch (Dali::DaliException e) {
60737       {
60738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60739       };
60740     } catch (...) {
60741       {
60742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60743       };
60744     }
60745   }
60746
60747   jresult = (int)result;
60748   return jresult;
60749 }
60750
60751
60752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
60753   int jresult ;
60754   int result;
60755
60756   {
60757     try {
60758       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
60759     } catch (std::out_of_range& e) {
60760       {
60761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60762       };
60763     } catch (std::exception& e) {
60764       {
60765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60766       };
60767     } catch (Dali::DaliException e) {
60768       {
60769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60770       };
60771     } catch (...) {
60772       {
60773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60774       };
60775     }
60776   }
60777
60778   jresult = (int)result;
60779   return jresult;
60780 }
60781
60782
60783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
60784   int jresult ;
60785   int result;
60786
60787   {
60788     try {
60789       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
60790     } catch (std::out_of_range& e) {
60791       {
60792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60793       };
60794     } catch (std::exception& e) {
60795       {
60796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60797       };
60798     } catch (Dali::DaliException e) {
60799       {
60800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60801       };
60802     } catch (...) {
60803       {
60804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60805       };
60806     }
60807   }
60808
60809   jresult = (int)result;
60810   return jresult;
60811 }
60812
60813
60814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
60815   int jresult ;
60816   int result;
60817
60818   {
60819     try {
60820       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
60821     } catch (std::out_of_range& e) {
60822       {
60823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60824       };
60825     } catch (std::exception& e) {
60826       {
60827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60828       };
60829     } catch (Dali::DaliException e) {
60830       {
60831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60832       };
60833     } catch (...) {
60834       {
60835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60836       };
60837     }
60838   }
60839
60840   jresult = (int)result;
60841   return jresult;
60842 }
60843
60844
60845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
60846   int jresult ;
60847   int result;
60848
60849   {
60850     try {
60851       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
60852     } catch (std::out_of_range& e) {
60853       {
60854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60855       };
60856     } catch (std::exception& e) {
60857       {
60858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60859       };
60860     } catch (Dali::DaliException e) {
60861       {
60862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60863       };
60864     } catch (...) {
60865       {
60866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60867       };
60868     }
60869   }
60870
60871   jresult = (int)result;
60872   return jresult;
60873 }
60874
60875
60876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
60877   int jresult ;
60878   int result;
60879
60880   {
60881     try {
60882       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
60883     } catch (std::out_of_range& e) {
60884       {
60885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60886       };
60887     } catch (std::exception& e) {
60888       {
60889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60890       };
60891     } catch (Dali::DaliException e) {
60892       {
60893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60894       };
60895     } catch (...) {
60896       {
60897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60898       };
60899     }
60900   }
60901
60902   jresult = (int)result;
60903   return jresult;
60904 }
60905
60906
60907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
60908   int jresult ;
60909   int result;
60910
60911   {
60912     try {
60913       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
60914     } catch (std::out_of_range& e) {
60915       {
60916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60917       };
60918     } catch (std::exception& e) {
60919       {
60920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60921       };
60922     } catch (Dali::DaliException e) {
60923       {
60924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60925       };
60926     } catch (...) {
60927       {
60928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60929       };
60930     }
60931   }
60932
60933   jresult = (int)result;
60934   return jresult;
60935 }
60936
60937
60938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
60939   int jresult ;
60940   int result;
60941
60942   {
60943     try {
60944       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
60945     } catch (std::out_of_range& e) {
60946       {
60947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60948       };
60949     } catch (std::exception& e) {
60950       {
60951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60952       };
60953     } catch (Dali::DaliException e) {
60954       {
60955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60956       };
60957     } catch (...) {
60958       {
60959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60960       };
60961     }
60962   }
60963
60964   jresult = (int)result;
60965   return jresult;
60966 }
60967
60968
60969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
60970   int jresult ;
60971   int result;
60972
60973   {
60974     try {
60975       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
60976     } catch (std::out_of_range& e) {
60977       {
60978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60979       };
60980     } catch (std::exception& e) {
60981       {
60982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60983       };
60984     } catch (Dali::DaliException e) {
60985       {
60986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60987       };
60988     } catch (...) {
60989       {
60990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60991       };
60992     }
60993   }
60994
60995   jresult = (int)result;
60996   return jresult;
60997 }
60998
60999
61000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
61001   int jresult ;
61002   int result;
61003
61004   {
61005     try {
61006       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
61007     } catch (std::out_of_range& e) {
61008       {
61009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61010       };
61011     } catch (std::exception& e) {
61012       {
61013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61014       };
61015     } catch (Dali::DaliException e) {
61016       {
61017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61018       };
61019     } catch (...) {
61020       {
61021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61022       };
61023     }
61024   }
61025
61026   jresult = (int)result;
61027   return jresult;
61028 }
61029
61030
61031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
61032   int jresult ;
61033   int result;
61034
61035   {
61036     try {
61037       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
61038     } catch (std::out_of_range& e) {
61039       {
61040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61041       };
61042     } catch (std::exception& e) {
61043       {
61044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61045       };
61046     } catch (Dali::DaliException e) {
61047       {
61048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61049       };
61050     } catch (...) {
61051       {
61052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61053       };
61054     }
61055   }
61056
61057   jresult = (int)result;
61058   return jresult;
61059 }
61060
61061
61062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
61063   int jresult ;
61064   int result;
61065
61066   {
61067     try {
61068       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
61069     } catch (std::out_of_range& e) {
61070       {
61071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61072       };
61073     } catch (std::exception& e) {
61074       {
61075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61076       };
61077     } catch (Dali::DaliException e) {
61078       {
61079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61080       };
61081     } catch (...) {
61082       {
61083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61084       };
61085     }
61086   }
61087
61088   jresult = (int)result;
61089   return jresult;
61090 }
61091
61092
61093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
61094   int jresult ;
61095   int result;
61096
61097   {
61098     try {
61099       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
61100     } catch (std::out_of_range& e) {
61101       {
61102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61103       };
61104     } catch (std::exception& e) {
61105       {
61106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61107       };
61108     } catch (Dali::DaliException e) {
61109       {
61110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61111       };
61112     } catch (...) {
61113       {
61114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61115       };
61116     }
61117   }
61118
61119   jresult = (int)result;
61120   return jresult;
61121 }
61122
61123
61124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
61125   int jresult ;
61126   int result;
61127
61128   {
61129     try {
61130       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
61131     } catch (std::out_of_range& e) {
61132       {
61133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61134       };
61135     } catch (std::exception& e) {
61136       {
61137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61138       };
61139     } catch (Dali::DaliException e) {
61140       {
61141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61142       };
61143     } catch (...) {
61144       {
61145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61146       };
61147     }
61148   }
61149
61150   jresult = (int)result;
61151   return jresult;
61152 }
61153
61154
61155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
61156   void * jresult ;
61157   Dali::Toolkit::Control result;
61158
61159   {
61160     try {
61161       result = Dali::Toolkit::Internal::Control::New();
61162     } catch (std::out_of_range& e) {
61163       {
61164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61165       };
61166     } catch (std::exception& e) {
61167       {
61168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61169       };
61170     } catch (Dali::DaliException e) {
61171       {
61172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61173       };
61174     } catch (...) {
61175       {
61176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61177       };
61178     }
61179   }
61180
61181   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
61182   return jresult;
61183 }
61184
61185
61186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
61187   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61188   std::string *arg2 = 0 ;
61189
61190   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61191   if (!jarg2) {
61192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61193     return ;
61194   }
61195   std::string arg2_str(jarg2);
61196   arg2 = &arg2_str;
61197   {
61198     try {
61199       (arg1)->SetStyleName((std::string const &)*arg2);
61200     } catch (std::out_of_range& e) {
61201       {
61202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61203       };
61204     } catch (std::exception& e) {
61205       {
61206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61207       };
61208     } catch (Dali::DaliException e) {
61209       {
61210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61211       };
61212     } catch (...) {
61213       {
61214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61215       };
61216     }
61217   }
61218
61219
61220   //argout typemap for const std::string&
61221
61222 }
61223
61224
61225 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
61226   char * jresult ;
61227   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61228   std::string *result = 0 ;
61229
61230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61231   {
61232     try {
61233       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
61234     } catch (std::out_of_range& e) {
61235       {
61236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61237       };
61238     } catch (std::exception& e) {
61239       {
61240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61241       };
61242     } catch (Dali::DaliException e) {
61243       {
61244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61245       };
61246     } catch (...) {
61247       {
61248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61249       };
61250     }
61251   }
61252
61253   jresult = SWIG_csharp_string_callback(result->c_str());
61254   return jresult;
61255 }
61256
61257
61258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
61259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61260   Dali::Vector4 *arg2 = 0 ;
61261
61262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61263   arg2 = (Dali::Vector4 *)jarg2;
61264   if (!arg2) {
61265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
61266     return ;
61267   }
61268   {
61269     try {
61270       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
61271     } catch (std::out_of_range& e) {
61272       {
61273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61274       };
61275     } catch (std::exception& e) {
61276       {
61277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61278       };
61279     } catch (Dali::DaliException e) {
61280       {
61281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61282       };
61283     } catch (...) {
61284       {
61285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61286       };
61287     }
61288   }
61289
61290 }
61291
61292
61293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
61294   void * jresult ;
61295   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
61296   Dali::Vector4 result;
61297
61298   arg1 = (Dali::Handle *)jarg1;
61299   {
61300     try {
61301       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
61302       if (resultMap)
61303       {
61304         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
61305         if(type && type->Get<int>() == Visual::COLOR )
61306         {
61307           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
61308           if (value)
61309           {
61310             result = value->Get<Vector4>();
61311           }
61312         }
61313       }
61314     } catch (std::out_of_range& e) {
61315       {
61316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61317       };
61318     } catch (std::exception& e) {
61319       {
61320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61321       };
61322     } catch (Dali::DaliException e) {
61323       {
61324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61325       };
61326     } catch (...) {
61327       {
61328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61329       };
61330     }
61331   }
61332
61333   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
61334   return jresult;
61335 }
61336
61337
61338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
61339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61340   Dali::Property::Map *arg2 = 0 ;
61341
61342   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61343   arg2 = (Dali::Property::Map *)jarg2;
61344   if (!arg2) {
61345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61346     return ;
61347   }
61348   {
61349     try {
61350       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
61351     } catch (std::out_of_range& e) {
61352       {
61353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61354       };
61355     } catch (std::exception& e) {
61356       {
61357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61358       };
61359     } catch (Dali::DaliException e) {
61360       {
61361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61362       };
61363     } catch (...) {
61364       {
61365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61366       };
61367     }
61368   }
61369
61370 }
61371
61372
61373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
61374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61375
61376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61377   {
61378     try {
61379       (arg1)->ClearBackground();
61380     } catch (std::out_of_range& e) {
61381       {
61382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61383       };
61384     } catch (std::exception& e) {
61385       {
61386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61387       };
61388     } catch (Dali::DaliException e) {
61389       {
61390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61391       };
61392     } catch (...) {
61393       {
61394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61395       };
61396     }
61397   }
61398
61399 }
61400
61401
61402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
61403   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61404   Dali::Gesture::Type arg2 ;
61405
61406   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61407   arg2 = (Dali::Gesture::Type)jarg2;
61408   {
61409     try {
61410       (arg1)->EnableGestureDetection(arg2);
61411     } catch (std::out_of_range& e) {
61412       {
61413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61414       };
61415     } catch (std::exception& e) {
61416       {
61417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61418       };
61419     } catch (Dali::DaliException e) {
61420       {
61421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61422       };
61423     } catch (...) {
61424       {
61425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61426       };
61427     }
61428   }
61429
61430 }
61431
61432
61433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
61434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61435   Dali::Gesture::Type arg2 ;
61436
61437   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61438   arg2 = (Dali::Gesture::Type)jarg2;
61439   {
61440     try {
61441       (arg1)->DisableGestureDetection(arg2);
61442     } catch (std::out_of_range& e) {
61443       {
61444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61445       };
61446     } catch (std::exception& e) {
61447       {
61448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61449       };
61450     } catch (Dali::DaliException e) {
61451       {
61452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61453       };
61454     } catch (...) {
61455       {
61456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61457       };
61458     }
61459   }
61460
61461 }
61462
61463
61464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
61465   void * jresult ;
61466   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61467   Dali::PinchGestureDetector result;
61468
61469   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61470   {
61471     try {
61472       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
61473     } catch (std::out_of_range& e) {
61474       {
61475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61476       };
61477     } catch (std::exception& e) {
61478       {
61479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61480       };
61481     } catch (Dali::DaliException e) {
61482       {
61483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61484       };
61485     } catch (...) {
61486       {
61487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61488       };
61489     }
61490   }
61491
61492   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
61493   return jresult;
61494 }
61495
61496
61497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
61498   void * jresult ;
61499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61500   Dali::PanGestureDetector result;
61501
61502   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61503   {
61504     try {
61505       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
61506     } catch (std::out_of_range& e) {
61507       {
61508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61509       };
61510     } catch (std::exception& e) {
61511       {
61512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61513       };
61514     } catch (Dali::DaliException e) {
61515       {
61516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61517       };
61518     } catch (...) {
61519       {
61520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61521       };
61522     }
61523   }
61524
61525   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
61526   return jresult;
61527 }
61528
61529
61530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
61531   void * jresult ;
61532   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61533   Dali::TapGestureDetector result;
61534
61535   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61536   {
61537     try {
61538       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
61539     } catch (std::out_of_range& e) {
61540       {
61541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61542       };
61543     } catch (std::exception& e) {
61544       {
61545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61546       };
61547     } catch (Dali::DaliException e) {
61548       {
61549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61550       };
61551     } catch (...) {
61552       {
61553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61554       };
61555     }
61556   }
61557
61558   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
61559   return jresult;
61560 }
61561
61562
61563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
61564   void * jresult ;
61565   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61566   Dali::LongPressGestureDetector result;
61567
61568   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61569   {
61570     try {
61571       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
61572     } catch (std::out_of_range& e) {
61573       {
61574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61575       };
61576     } catch (std::exception& e) {
61577       {
61578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61579       };
61580     } catch (Dali::DaliException e) {
61581       {
61582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61583       };
61584     } catch (...) {
61585       {
61586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61587       };
61588     }
61589   }
61590
61591   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
61592   return jresult;
61593 }
61594
61595
61596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
61597   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61598   bool arg2 ;
61599
61600   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61601   arg2 = jarg2 ? true : false;
61602   {
61603     try {
61604       (arg1)->SetKeyboardNavigationSupport(arg2);
61605     } catch (std::out_of_range& e) {
61606       {
61607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61608       };
61609     } catch (std::exception& e) {
61610       {
61611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61612       };
61613     } catch (Dali::DaliException e) {
61614       {
61615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61616       };
61617     } catch (...) {
61618       {
61619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61620       };
61621     }
61622   }
61623
61624 }
61625
61626
61627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
61628   unsigned int jresult ;
61629   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61630   bool result;
61631
61632   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61633   {
61634     try {
61635       result = (bool)(arg1)->IsKeyboardNavigationSupported();
61636     } catch (std::out_of_range& e) {
61637       {
61638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61639       };
61640     } catch (std::exception& e) {
61641       {
61642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61643       };
61644     } catch (Dali::DaliException e) {
61645       {
61646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61647       };
61648     } catch (...) {
61649       {
61650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61651       };
61652     }
61653   }
61654
61655   jresult = result;
61656   return jresult;
61657 }
61658
61659
61660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
61661   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61662
61663   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61664   {
61665     try {
61666       (arg1)->SetKeyInputFocus();
61667     } catch (std::out_of_range& e) {
61668       {
61669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61670       };
61671     } catch (std::exception& e) {
61672       {
61673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61674       };
61675     } catch (Dali::DaliException e) {
61676       {
61677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61678       };
61679     } catch (...) {
61680       {
61681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61682       };
61683     }
61684   }
61685
61686 }
61687
61688
61689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
61690   unsigned int jresult ;
61691   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61692   bool result;
61693
61694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61695   {
61696     try {
61697       result = (bool)(arg1)->HasKeyInputFocus();
61698     } catch (std::out_of_range& e) {
61699       {
61700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61701       };
61702     } catch (std::exception& e) {
61703       {
61704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61705       };
61706     } catch (Dali::DaliException e) {
61707       {
61708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61709       };
61710     } catch (...) {
61711       {
61712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61713       };
61714     }
61715   }
61716
61717   jresult = result;
61718   return jresult;
61719 }
61720
61721
61722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
61723   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61724
61725   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61726   {
61727     try {
61728       (arg1)->ClearKeyInputFocus();
61729     } catch (std::out_of_range& e) {
61730       {
61731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61732       };
61733     } catch (std::exception& e) {
61734       {
61735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61736       };
61737     } catch (Dali::DaliException e) {
61738       {
61739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61740       };
61741     } catch (...) {
61742       {
61743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61744       };
61745     }
61746   }
61747
61748 }
61749
61750
61751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
61752   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61753   bool arg2 ;
61754
61755   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61756   arg2 = jarg2 ? true : false;
61757   {
61758     try {
61759       (arg1)->SetAsKeyboardFocusGroup(arg2);
61760     } catch (std::out_of_range& e) {
61761       {
61762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61763       };
61764     } catch (std::exception& e) {
61765       {
61766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61767       };
61768     } catch (Dali::DaliException e) {
61769       {
61770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61771       };
61772     } catch (...) {
61773       {
61774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61775       };
61776     }
61777   }
61778
61779 }
61780
61781
61782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
61783   unsigned int jresult ;
61784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61785   bool result;
61786
61787   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61788   {
61789     try {
61790       result = (bool)(arg1)->IsKeyboardFocusGroup();
61791     } catch (std::out_of_range& e) {
61792       {
61793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61794       };
61795     } catch (std::exception& e) {
61796       {
61797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61798       };
61799     } catch (Dali::DaliException e) {
61800       {
61801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61802       };
61803     } catch (...) {
61804       {
61805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61806       };
61807     }
61808   }
61809
61810   jresult = result;
61811   return jresult;
61812 }
61813
61814
61815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
61816   void * jresult ;
61817   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61818   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
61819
61820   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61821   {
61822     try {
61823       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
61824     } catch (std::out_of_range& e) {
61825       {
61826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61827       };
61828     } catch (std::exception& e) {
61829       {
61830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61831       };
61832     } catch (Dali::DaliException e) {
61833       {
61834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61835       };
61836     } catch (...) {
61837       {
61838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61839       };
61840     }
61841   }
61842
61843   jresult = (void *)result;
61844   return jresult;
61845 }
61846
61847
61848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
61849   void * jresult ;
61850   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61851   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
61852
61853   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61854   {
61855     try {
61856       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
61857     } catch (std::out_of_range& e) {
61858       {
61859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61860       };
61861     } catch (std::exception& e) {
61862       {
61863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61864       };
61865     } catch (Dali::DaliException e) {
61866       {
61867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61868       };
61869     } catch (...) {
61870       {
61871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61872       };
61873     }
61874   }
61875
61876   jresult = (void *)result;
61877   return jresult;
61878 }
61879
61880
61881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
61882   void * jresult ;
61883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61884   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
61885
61886   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61887   {
61888     try {
61889       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
61890     } catch (std::out_of_range& e) {
61891       {
61892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61893       };
61894     } catch (std::exception& e) {
61895       {
61896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61897       };
61898     } catch (Dali::DaliException e) {
61899       {
61900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61901       };
61902     } catch (...) {
61903       {
61904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61905       };
61906     }
61907   }
61908
61909   jresult = (void *)result;
61910   return jresult;
61911 }
61912
61913
61914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
61915   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61916   int arg2 ;
61917   SwigDirector_ViewImpl *darg = 0;
61918
61919   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61920   arg2 = (int)jarg2;
61921   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61922   if(!darg) {
61923     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61924     return;
61925   }
61926   {
61927     try {
61928       if(darg) {
61929         (darg)->OnStageConnection(arg2);
61930       }
61931     } catch (std::out_of_range& e) {
61932       {
61933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61934       };
61935     } catch (std::exception& e) {
61936       {
61937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61938       };
61939     } catch (Dali::DaliException e) {
61940       {
61941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61942       };
61943     } catch (...) {
61944       {
61945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61946       };
61947     }
61948   }
61949
61950 }
61951
61952
61953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
61954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61955   int arg2 ;
61956   SwigDirector_ViewImpl *darg = 0;
61957
61958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61959   arg2 = (int)jarg2;
61960   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61961   if(!darg) {
61962     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61963     return;
61964   }
61965   {
61966     try {
61967       if(darg) {
61968         (darg)->OnStageConnectionSwigPublic(arg2);
61969       }
61970     } catch (std::out_of_range& e) {
61971       {
61972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61973       };
61974     } catch (std::exception& e) {
61975       {
61976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61977       };
61978     } catch (Dali::DaliException e) {
61979       {
61980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61981       };
61982     } catch (...) {
61983       {
61984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61985       };
61986     }
61987   }
61988
61989 }
61990
61991
61992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
61993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61994   SwigDirector_ViewImpl *darg = 0;
61995
61996   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61997   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61998   if(!darg) {
61999     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62000     return;
62001   }
62002   {
62003     try {
62004       if(darg) {
62005         (darg)->OnStageDisconnection();
62006       }
62007     } catch (std::out_of_range& e) {
62008       {
62009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62010       };
62011     } catch (std::exception& e) {
62012       {
62013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62014       };
62015     } catch (Dali::DaliException e) {
62016       {
62017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62018       };
62019     } catch (...) {
62020       {
62021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62022       };
62023     }
62024   }
62025
62026 }
62027
62028
62029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
62030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62031   SwigDirector_ViewImpl *darg = 0;
62032
62033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62034   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62035   if(!darg) {
62036     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62037     return;
62038   }
62039   {
62040     try {
62041       if(darg) {
62042         (darg)->OnStageDisconnectionSwigPublic();
62043       }
62044     } catch (std::out_of_range& e) {
62045       {
62046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62047       };
62048     } catch (std::exception& e) {
62049       {
62050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62051       };
62052     } catch (Dali::DaliException e) {
62053       {
62054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62055       };
62056     } catch (...) {
62057       {
62058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62059       };
62060     }
62061   }
62062
62063 }
62064
62065
62066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
62067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62068   Dali::Actor *arg2 = 0 ;
62069   SwigDirector_ViewImpl *darg = 0;
62070
62071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62072   arg2 = (Dali::Actor *)jarg2;
62073   if (!arg2) {
62074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62075     return ;
62076   }
62077   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62078   if(!darg) {
62079     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62080     return;
62081   }
62082   {
62083     try {
62084       if(darg) {
62085         (darg)->OnChildAdd(*arg2);
62086       }
62087     } catch (std::out_of_range& e) {
62088       {
62089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62090       };
62091     } catch (std::exception& e) {
62092       {
62093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62094       };
62095     } catch (Dali::DaliException e) {
62096       {
62097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62098       };
62099     } catch (...) {
62100       {
62101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62102       };
62103     }
62104   }
62105
62106 }
62107
62108
62109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62111   Dali::Actor *arg2 = 0 ;
62112   SwigDirector_ViewImpl *darg = 0;
62113
62114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62115   arg2 = (Dali::Actor *)jarg2;
62116   if (!arg2) {
62117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62118     return ;
62119   }
62120   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62121   if(!darg) {
62122     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62123     return;
62124   }
62125   {
62126     try {
62127       if(darg) {
62128           (darg)->OnChildAddSwigPublic(*arg2);
62129       }
62130     } catch (std::out_of_range& e) {
62131       {
62132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62133       };
62134     } catch (std::exception& e) {
62135       {
62136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62137       };
62138     } catch (Dali::DaliException e) {
62139       {
62140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62141       };
62142     } catch (...) {
62143       {
62144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62145       };
62146     }
62147   }
62148
62149 }
62150
62151
62152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
62153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62154   Dali::Actor *arg2 = 0 ;
62155   SwigDirector_ViewImpl *darg = 0;
62156
62157   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62158   arg2 = (Dali::Actor *)jarg2;
62159   if (!arg2) {
62160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62161     return ;
62162   }
62163   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62164   if(!darg) {
62165     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62166     return;
62167   }
62168   {
62169     try {
62170       if(darg) {
62171         (darg)->OnChildRemove(*arg2);
62172       }
62173     } catch (std::out_of_range& e) {
62174       {
62175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62176       };
62177     } catch (std::exception& e) {
62178       {
62179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62180       };
62181     } catch (Dali::DaliException e) {
62182       {
62183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62184       };
62185     } catch (...) {
62186       {
62187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62188       };
62189     }
62190   }
62191
62192 }
62193
62194
62195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62196   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62197   Dali::Actor *arg2 = 0 ;
62198   SwigDirector_ViewImpl *darg = 0;
62199
62200   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62201   arg2 = (Dali::Actor *)jarg2;
62202   if (!arg2) {
62203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62204     return ;
62205   }
62206   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62207   if(!darg) {
62208     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62209     return;
62210   }
62211   {
62212     try {
62213       if(darg) {
62214         (darg)->OnChildRemoveSwigPublic(*arg2);
62215       }
62216     } catch (std::out_of_range& e) {
62217       {
62218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62219       };
62220     } catch (std::exception& e) {
62221       {
62222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62223       };
62224     } catch (Dali::DaliException e) {
62225       {
62226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62227       };
62228     } catch (...) {
62229       {
62230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62231       };
62232     }
62233   }
62234
62235 }
62236
62237
62238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
62239   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62240   Dali::Property::Index arg2 ;
62241   Dali::Property::Value arg3 ;
62242   Dali::Property::Value *argp3 ;
62243   SwigDirector_ViewImpl *darg = 0;
62244
62245   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62246   arg2 = (Dali::Property::Index)jarg2;
62247   argp3 = (Dali::Property::Value *)jarg3;
62248   if (!argp3) {
62249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
62250     return ;
62251   }
62252   arg3 = *argp3;
62253   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62254   if (!darg) {
62255     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62256     return;
62257   }
62258   {
62259     try {
62260       (darg)->OnPropertySet(arg2,arg3);
62261     } catch (std::out_of_range& e) {
62262       {
62263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62264       };
62265     } catch (std::exception& e) {
62266       {
62267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62268       };
62269     } catch (Dali::DaliException e) {
62270       {
62271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62272       };
62273     } catch (...) {
62274       {
62275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62276       };
62277     }
62278   }
62279
62280 }
62281
62282
62283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
62284   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62285   Dali::Property::Index arg2 ;
62286   Dali::Property::Value arg3 ;
62287   Dali::Property::Value *argp3 ;
62288   SwigDirector_ViewImpl *darg = 0;
62289
62290   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62291   arg2 = (Dali::Property::Index)jarg2;
62292   argp3 = (Dali::Property::Value *)jarg3;
62293   if (!argp3) {
62294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
62295     return ;
62296   }
62297   arg3 = *argp3;
62298   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62299   if (!darg) {
62300     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62301     return;
62302   }
62303   {
62304     try {
62305       (darg)->OnPropertySetSwigPublic(arg2,arg3);
62306     } catch (std::out_of_range& e) {
62307       {
62308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62309       };
62310     } catch (std::exception& e) {
62311       {
62312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62313       };
62314     } catch (Dali::DaliException e) {
62315       {
62316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62317       };
62318     } catch (...) {
62319       {
62320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62321       };
62322     }
62323   }
62324
62325 }
62326
62327
62328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
62329   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62330   Dali::Vector3 *arg2 = 0 ;
62331   SwigDirector_ViewImpl *darg = 0;
62332
62333   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62334   arg2 = (Dali::Vector3 *)jarg2;
62335   if (!arg2) {
62336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
62337     return ;
62338   }
62339   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62340   if (!darg) {
62341     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62342     return;
62343   }
62344   {
62345     try {
62346       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
62347     } catch (std::out_of_range& e) {
62348       {
62349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62350       };
62351     } catch (std::exception& e) {
62352       {
62353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62354       };
62355     } catch (Dali::DaliException e) {
62356       {
62357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62358       };
62359     } catch (...) {
62360       {
62361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62362       };
62363     }
62364   }
62365
62366 }
62367
62368
62369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62370   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62371   Dali::Vector3 *arg2 = 0 ;
62372   SwigDirector_ViewImpl *darg = 0;
62373
62374   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62375   arg2 = (Dali::Vector3 *)jarg2;
62376   if (!arg2) {
62377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
62378     return ;
62379   }
62380   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62381   if (!darg) {
62382     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62383     return;
62384   }
62385   {
62386     try {
62387       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
62388     } catch (std::out_of_range& e) {
62389       {
62390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62391       };
62392     } catch (std::exception& e) {
62393       {
62394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62395       };
62396     } catch (Dali::DaliException e) {
62397       {
62398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62399       };
62400     } catch (...) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62403       };
62404     }
62405   }
62406
62407 }
62408
62409
62410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
62411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62412   Dali::Animation *arg2 = 0 ;
62413   Dali::Vector3 *arg3 = 0 ;
62414   SwigDirector_ViewImpl *darg = 0;
62415
62416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62417   arg2 = (Dali::Animation *)jarg2;
62418   if (!arg2) {
62419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
62420     return ;
62421   }
62422   arg3 = (Dali::Vector3 *)jarg3;
62423   if (!arg3) {
62424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
62425     return ;
62426   }
62427   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62428   if (!darg) {
62429     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62430     return;
62431   }
62432   {
62433     try {
62434       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
62435     } catch (std::out_of_range& e) {
62436       {
62437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62438       };
62439     } catch (std::exception& e) {
62440       {
62441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62442       };
62443     } catch (Dali::DaliException e) {
62444       {
62445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62446       };
62447     } catch (...) {
62448       {
62449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62450       };
62451     }
62452   }
62453
62454 }
62455
62456
62457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62458   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62459   Dali::Animation *arg2 = 0 ;
62460   Dali::Vector3 *arg3 = 0 ;
62461   SwigDirector_ViewImpl *darg = 0;
62462
62463   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62464   arg2 = (Dali::Animation *)jarg2;
62465   if (!arg2) {
62466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
62467     return ;
62468   }
62469   arg3 = (Dali::Vector3 *)jarg3;
62470   if (!arg3) {
62471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
62472     return ;
62473   }
62474   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62475   if (!darg) {
62476     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62477     return;
62478   }
62479   {
62480     try {
62481       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
62482     } catch (std::out_of_range& e) {
62483       {
62484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62485       };
62486     } catch (std::exception& e) {
62487       {
62488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62489       };
62490     } catch (Dali::DaliException e) {
62491       {
62492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62493       };
62494     } catch (...) {
62495       {
62496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62497       };
62498     }
62499   }
62500
62501 }
62502
62503
62504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
62505   unsigned int jresult ;
62506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62507   Dali::TouchEvent *arg2 = 0 ;
62508   SwigDirector_ViewImpl *darg = 0;
62509   bool result;
62510
62511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62512   arg2 = (Dali::TouchEvent *)jarg2;
62513   if (!arg2) {
62514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62515     return 0;
62516   }
62517   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62518   if (!darg) {
62519     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62520     return 0;
62521   }
62522   {
62523     try {
62524       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
62525     } catch (std::out_of_range& e) {
62526       {
62527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62528       };
62529     } catch (std::exception& e) {
62530       {
62531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62532       };
62533     } catch (Dali::DaliException e) {
62534       {
62535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62536       };
62537     } catch (...) {
62538       {
62539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62540       };
62541     }
62542   }
62543
62544   jresult = result;
62545   return jresult;
62546 }
62547
62548
62549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62550   unsigned int jresult ;
62551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62552   Dali::TouchEvent *arg2 = 0 ;
62553   SwigDirector_ViewImpl *darg = 0;
62554   bool result;
62555
62556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62557   arg2 = (Dali::TouchEvent *)jarg2;
62558   if (!arg2) {
62559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62560     return 0;
62561   }
62562   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62563   if (!darg) {
62564     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62565     return 0;
62566   }
62567   {
62568     try {
62569       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
62570     } catch (std::out_of_range& e) {
62571       {
62572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62573       };
62574     } catch (std::exception& e) {
62575       {
62576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62577       };
62578     } catch (Dali::DaliException e) {
62579       {
62580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62581       };
62582     } catch (...) {
62583       {
62584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62585       };
62586     }
62587   }
62588
62589   jresult = result;
62590   return jresult;
62591 }
62592
62593
62594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
62595   unsigned int jresult ;
62596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62597   Dali::HoverEvent *arg2 = 0 ;
62598   SwigDirector_ViewImpl *darg = 0;
62599   bool result;
62600
62601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62602   arg2 = (Dali::HoverEvent *)jarg2;
62603   if (!arg2) {
62604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
62605     return 0;
62606   }
62607   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62608   if (!darg) {
62609     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62610     return 0;
62611   }
62612   {
62613     try {
62614       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
62615     } catch (std::out_of_range& e) {
62616       {
62617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62618       };
62619     } catch (std::exception& e) {
62620       {
62621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62622       };
62623     } catch (Dali::DaliException e) {
62624       {
62625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62626       };
62627     } catch (...) {
62628       {
62629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62630       };
62631     }
62632   }
62633
62634   jresult = result;
62635   return jresult;
62636 }
62637
62638
62639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62640   unsigned int jresult ;
62641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62642   Dali::HoverEvent *arg2 = 0 ;
62643   SwigDirector_ViewImpl *darg = 0;
62644   bool result;
62645
62646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62647   arg2 = (Dali::HoverEvent *)jarg2;
62648   if (!arg2) {
62649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
62650     return 0;
62651   }
62652   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62653   if (!darg) {
62654     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62655     return 0;
62656   }
62657   {
62658     try {
62659       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
62660     } catch (std::out_of_range& e) {
62661       {
62662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62663       };
62664     } catch (std::exception& e) {
62665       {
62666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62667       };
62668     } catch (Dali::DaliException e) {
62669       {
62670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62671       };
62672     } catch (...) {
62673       {
62674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62675       };
62676     }
62677   }
62678
62679   jresult = result;
62680   return jresult;
62681 }
62682
62683
62684 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
62685   unsigned int jresult ;
62686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62687   Dali::KeyEvent *arg2 = 0 ;
62688   SwigDirector_ViewImpl *darg = 0;
62689   bool result;
62690
62691   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62692   arg2 = (Dali::KeyEvent *)jarg2;
62693   if (!arg2) {
62694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
62695     return 0;
62696   }
62697   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62698   if (!darg) {
62699     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62700     return 0;
62701   }
62702   {
62703     try {
62704       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
62705     } catch (std::out_of_range& e) {
62706       {
62707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62708       };
62709     } catch (std::exception& e) {
62710       {
62711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62712       };
62713     } catch (Dali::DaliException e) {
62714       {
62715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62716       };
62717     } catch (...) {
62718       {
62719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62720       };
62721     }
62722   }
62723
62724   jresult = result;
62725   return jresult;
62726 }
62727
62728
62729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62730   unsigned int jresult ;
62731   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62732   Dali::KeyEvent *arg2 = 0 ;
62733   SwigDirector_ViewImpl *darg = 0;
62734   bool result;
62735
62736   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62737   arg2 = (Dali::KeyEvent *)jarg2;
62738   if (!arg2) {
62739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
62740     return 0;
62741   }
62742   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62743   if (!darg) {
62744     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62745     return 0;
62746   }
62747   {
62748     try {
62749       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
62750     } catch (std::out_of_range& e) {
62751       {
62752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62753       };
62754     } catch (std::exception& e) {
62755       {
62756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62757       };
62758     } catch (Dali::DaliException e) {
62759       {
62760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62761       };
62762     } catch (...) {
62763       {
62764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62765       };
62766     }
62767   }
62768
62769   jresult = result;
62770   return jresult;
62771 }
62772
62773
62774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
62775   unsigned int jresult ;
62776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62777   Dali::WheelEvent *arg2 = 0 ;
62778   SwigDirector_ViewImpl *darg = 0;
62779   bool result;
62780
62781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62782   arg2 = (Dali::WheelEvent *)jarg2;
62783   if (!arg2) {
62784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
62785     return 0;
62786   }
62787   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62788   if (!darg) {
62789     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62790     return 0;
62791   }
62792   {
62793     try {
62794       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
62795     } catch (std::out_of_range& e) {
62796       {
62797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62798       };
62799     } catch (std::exception& e) {
62800       {
62801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62802       };
62803     } catch (Dali::DaliException e) {
62804       {
62805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62806       };
62807     } catch (...) {
62808       {
62809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62810       };
62811     }
62812   }
62813
62814   jresult = result;
62815   return jresult;
62816 }
62817
62818
62819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62820   unsigned int jresult ;
62821   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62822   Dali::WheelEvent *arg2 = 0 ;
62823   SwigDirector_ViewImpl *darg = 0;
62824   bool result;
62825
62826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62827   arg2 = (Dali::WheelEvent *)jarg2;
62828   if (!arg2) {
62829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
62830     return 0;
62831   }
62832   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62833   if (!darg) {
62834     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62835     return 0;
62836   }
62837   {
62838     try {
62839       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
62840     } catch (std::out_of_range& e) {
62841       {
62842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62843       };
62844     } catch (std::exception& e) {
62845       {
62846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62847       };
62848     } catch (Dali::DaliException e) {
62849       {
62850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62851       };
62852     } catch (...) {
62853       {
62854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62855       };
62856     }
62857   }
62858
62859   jresult = result;
62860   return jresult;
62861 }
62862
62863
62864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
62865   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62866   Dali::Vector2 *arg2 = 0 ;
62867   Dali::RelayoutContainer *arg3 = 0 ;
62868   SwigDirector_ViewImpl *darg = 0;
62869
62870   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62871   arg2 = (Dali::Vector2 *)jarg2;
62872   if (!arg2) {
62873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
62874     return ;
62875   }
62876   arg3 = (Dali::RelayoutContainer *)jarg3;
62877   if (!arg3) {
62878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
62879     return ;
62880   }
62881   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62882   if (!darg) {
62883     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62884     return;
62885   }
62886   {
62887     try {
62888       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
62889     } catch (std::out_of_range& e) {
62890       {
62891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62892       };
62893     } catch (std::exception& e) {
62894       {
62895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62896       };
62897     } catch (Dali::DaliException e) {
62898       {
62899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62900       };
62901     } catch (...) {
62902       {
62903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62904       };
62905     }
62906   }
62907
62908 }
62909
62910
62911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62912   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62913   Dali::Vector2 *arg2 = 0 ;
62914   Dali::RelayoutContainer *arg3 = 0 ;
62915   SwigDirector_ViewImpl *darg = 0;
62916
62917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62918   arg2 = (Dali::Vector2 *)jarg2;
62919   if (!arg2) {
62920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
62921     return ;
62922   }
62923   arg3 = (Dali::RelayoutContainer *)jarg3;
62924   if (!arg3) {
62925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
62926     return ;
62927   }
62928   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62929   if (!darg) {
62930     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62931     return;
62932   }
62933   {
62934     try {
62935       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
62936     } catch (std::out_of_range& e) {
62937       {
62938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62939       };
62940     } catch (std::exception& e) {
62941       {
62942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62943       };
62944     } catch (Dali::DaliException e) {
62945       {
62946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62947       };
62948     } catch (...) {
62949       {
62950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62951       };
62952     }
62953   }
62954
62955 }
62956
62957
62958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
62959   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62960   Dali::ResizePolicy::Type arg2 ;
62961   Dali::Dimension::Type arg3 ;
62962   SwigDirector_ViewImpl *darg = 0;
62963
62964   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62965   arg2 = (Dali::ResizePolicy::Type)jarg2;
62966   arg3 = (Dali::Dimension::Type)jarg3;
62967   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62968   if (!darg) {
62969     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62970     return;
62971   }
62972   {
62973     try {
62974       (darg)->OnSetResizePolicy(arg2,arg3);
62975     } catch (std::out_of_range& e) {
62976       {
62977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62978       };
62979     } catch (std::exception& e) {
62980       {
62981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62982       };
62983     } catch (Dali::DaliException e) {
62984       {
62985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62986       };
62987     } catch (...) {
62988       {
62989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62990       };
62991     }
62992   }
62993
62994 }
62995
62996
62997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
62998   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62999   Dali::ResizePolicy::Type arg2 ;
63000   Dali::Dimension::Type arg3 ;
63001   SwigDirector_ViewImpl *darg = 0;
63002
63003   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63004   arg2 = (Dali::ResizePolicy::Type)jarg2;
63005   arg3 = (Dali::Dimension::Type)jarg3;
63006   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63007   if (!darg) {
63008     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63009     return;
63010   }
63011   {
63012     try {
63013       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
63014     } catch (std::out_of_range& e) {
63015       {
63016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63017       };
63018     } catch (std::exception& e) {
63019       {
63020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63021       };
63022     } catch (Dali::DaliException e) {
63023       {
63024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63025       };
63026     } catch (...) {
63027       {
63028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63029       };
63030     }
63031   }
63032
63033 }
63034
63035
63036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
63037   void * jresult ;
63038   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63039   SwigDirector_ViewImpl *darg = 0;
63040   Dali::Vector3 result;
63041
63042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63043   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63044   if (!darg) {
63045     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63046     return 0;
63047   }
63048   {
63049     try {
63050       result = (darg)->GetNaturalSize();
63051     } catch (std::out_of_range& e) {
63052       {
63053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63054       };
63055     } catch (std::exception& e) {
63056       {
63057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63058       };
63059     } catch (Dali::DaliException e) {
63060       {
63061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63062       };
63063     } catch (...) {
63064       {
63065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63066       };
63067     }
63068   }
63069
63070   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
63071   return jresult;
63072 }
63073
63074
63075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
63076   void * jresult ;
63077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63078   SwigDirector_ViewImpl *darg = 0;
63079   Dali::Vector3 result;
63080
63081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63082   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63083   if (!darg) {
63084     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63085     return 0;
63086   }
63087   {
63088     try {
63089       result = (darg)->GetNaturalSizeSwigPublic();
63090     } catch (std::out_of_range& e) {
63091       {
63092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63093       };
63094     } catch (std::exception& e) {
63095       {
63096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63097       };
63098     } catch (Dali::DaliException e) {
63099       {
63100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63101       };
63102     } catch (...) {
63103       {
63104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63105       };
63106     }
63107   }
63108
63109   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
63110   return jresult;
63111 }
63112
63113
63114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
63115   float jresult ;
63116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63117   Dali::Actor *arg2 = 0 ;
63118   Dali::Dimension::Type arg3 ;
63119   SwigDirector_ViewImpl *darg = 0;
63120   float result;
63121
63122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63123   arg2 = (Dali::Actor *)jarg2;
63124   if (!arg2) {
63125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
63126     return 0;
63127   }
63128   arg3 = (Dali::Dimension::Type)jarg3;
63129   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63130   if (!darg) {
63131     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63132     return 0;
63133   }
63134   {
63135     try {
63136       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
63137     } catch (std::out_of_range& e) {
63138       {
63139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63140       };
63141     } catch (std::exception& e) {
63142       {
63143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63144       };
63145     } catch (Dali::DaliException e) {
63146       {
63147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63148       };
63149     } catch (...) {
63150       {
63151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63152       };
63153     }
63154   }
63155
63156   jresult = result;
63157   return jresult;
63158 }
63159
63160
63161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
63162   float jresult ;
63163   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63164   Dali::Actor *arg2 = 0 ;
63165   Dali::Dimension::Type arg3 ;
63166   SwigDirector_ViewImpl *darg = 0;
63167   float result;
63168
63169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63170   arg2 = (Dali::Actor *)jarg2;
63171   if (!arg2) {
63172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
63173     return 0;
63174   }
63175   arg3 = (Dali::Dimension::Type)jarg3;
63176   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63177   if (!darg) {
63178     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63179     return 0;
63180   }
63181   {
63182     try {
63183       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
63184     } catch (std::out_of_range& e) {
63185       {
63186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63187       };
63188     } catch (std::exception& e) {
63189       {
63190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63191       };
63192     } catch (Dali::DaliException e) {
63193       {
63194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63195       };
63196     } catch (...) {
63197       {
63198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63199       };
63200     }
63201   }
63202
63203   jresult = result;
63204   return jresult;
63205 }
63206
63207
63208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
63209   float jresult ;
63210   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63211   float arg2 ;
63212   SwigDirector_ViewImpl *darg = 0;
63213   float result;
63214
63215   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63216   arg2 = (float)jarg2;
63217   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63218   if (!darg) {
63219     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63220     return 0;
63221   }
63222   {
63223     try {
63224       result = (float)(darg)->GetHeightForWidth(arg2);
63225     } catch (std::out_of_range& e) {
63226       {
63227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63228       };
63229     } catch (std::exception& e) {
63230       {
63231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63232       };
63233     } catch (Dali::DaliException e) {
63234       {
63235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63236       };
63237     } catch (...) {
63238       {
63239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63240       };
63241     }
63242   }
63243
63244   jresult = result;
63245   return jresult;
63246 }
63247
63248
63249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
63250   float jresult ;
63251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63252   float arg2 ;
63253   SwigDirector_ViewImpl *darg = 0;
63254   float result;
63255
63256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63257   arg2 = (float)jarg2;
63258   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63259   if (!darg) {
63260     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63261     return 0;
63262   }
63263   {
63264     try {
63265       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
63266     } catch (std::out_of_range& e) {
63267       {
63268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63269       };
63270     } catch (std::exception& e) {
63271       {
63272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63273       };
63274     } catch (Dali::DaliException e) {
63275       {
63276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63277       };
63278     } catch (...) {
63279       {
63280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63281       };
63282     }
63283   }
63284
63285   jresult = result;
63286   return jresult;
63287 }
63288
63289
63290 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
63291   float jresult ;
63292   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63293   float arg2 ;
63294   SwigDirector_ViewImpl *darg = 0;
63295   float result;
63296
63297   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63298   arg2 = (float)jarg2;
63299   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63300   if (!darg) {
63301     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63302     return 0;
63303   }
63304   {
63305     try {
63306       result = (float)(darg)->GetWidthForHeight(arg2);
63307     } catch (std::out_of_range& e) {
63308       {
63309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63310       };
63311     } catch (std::exception& e) {
63312       {
63313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63314       };
63315     } catch (Dali::DaliException e) {
63316       {
63317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63318       };
63319     } catch (...) {
63320       {
63321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63322       };
63323     }
63324   }
63325
63326   jresult = result;
63327   return jresult;
63328 }
63329
63330
63331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
63332   float jresult ;
63333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63334   float arg2 ;
63335   SwigDirector_ViewImpl *darg = 0;
63336   float result;
63337
63338   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63339   arg2 = (float)jarg2;
63340   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63341   if (!darg) {
63342     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63343     return 0;
63344   }
63345   {
63346     try {
63347       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
63348     } catch (std::out_of_range& e) {
63349       {
63350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63351       };
63352     } catch (std::exception& e) {
63353       {
63354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63355       };
63356     } catch (Dali::DaliException e) {
63357       {
63358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63359       };
63360     } catch (...) {
63361       {
63362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63363       };
63364     }
63365   }
63366
63367   jresult = result;
63368   return jresult;
63369 }
63370
63371
63372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
63373   unsigned int jresult ;
63374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63375   Dali::Dimension::Type arg2 ;
63376   SwigDirector_ViewImpl *darg = 0;
63377   bool result;
63378
63379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63380   arg2 = (Dali::Dimension::Type)jarg2;
63381   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63382   if (!darg) {
63383     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63384     return 0;
63385   }
63386   {
63387     try {
63388       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
63389     } catch (std::out_of_range& e) {
63390       {
63391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63392       };
63393     } catch (std::exception& e) {
63394       {
63395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63396       };
63397     } catch (Dali::DaliException e) {
63398       {
63399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63400       };
63401     } catch (...) {
63402       {
63403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63404       };
63405     }
63406   }
63407
63408   jresult = result;
63409   return jresult;
63410 }
63411
63412
63413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
63414   unsigned int jresult ;
63415   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63416   Dali::Dimension::Type arg2 ;
63417   SwigDirector_ViewImpl *darg = 0;
63418   bool result;
63419
63420   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63421   arg2 = (Dali::Dimension::Type)jarg2;
63422   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63423   if (!darg) {
63424     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63425     return 0;
63426   }
63427   {
63428     try {
63429       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
63430     } catch (std::out_of_range& e) {
63431       {
63432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63433       };
63434     } catch (std::exception& e) {
63435       {
63436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63437       };
63438     } catch (Dali::DaliException e) {
63439       {
63440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63441       };
63442     } catch (...) {
63443       {
63444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63445       };
63446     }
63447   }
63448
63449   jresult = result;
63450   return jresult;
63451 }
63452
63453
63454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
63455   unsigned int jresult ;
63456   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63457   SwigDirector_ViewImpl *darg = 0;
63458   bool result;
63459
63460   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63461   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63462   if (!darg) {
63463     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63464     return 0;
63465   }
63466   {
63467     try {
63468       result = (bool)(darg)->RelayoutDependentOnChildren();
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 = result;
63489   return jresult;
63490 }
63491
63492
63493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
63494   unsigned int jresult ;
63495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63496   SwigDirector_ViewImpl *darg = 0;
63497   bool result;
63498
63499   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63500   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63501   if (!darg) {
63502     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63503     return 0;
63504   }
63505   {
63506     try {
63507       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
63508     } catch (std::out_of_range& e) {
63509       {
63510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63511       };
63512     } catch (std::exception& e) {
63513       {
63514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63515       };
63516     } catch (Dali::DaliException e) {
63517       {
63518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63519       };
63520     } catch (...) {
63521       {
63522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63523       };
63524     }
63525   }
63526
63527   jresult = result;
63528   return jresult;
63529 }
63530
63531
63532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
63533   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63534   Dali::Dimension::Type arg2 ;
63535   SwigDirector_ViewImpl *darg = 0;
63536
63537   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63538   arg2 = (Dali::Dimension::Type)jarg2;
63539   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63540   if (!darg) {
63541     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63542     return;
63543   }
63544   {
63545     try {
63546       (darg)->OnCalculateRelayoutSize(arg2);
63547     } catch (std::out_of_range& e) {
63548       {
63549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63550       };
63551     } catch (std::exception& e) {
63552       {
63553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63554       };
63555     } catch (Dali::DaliException e) {
63556       {
63557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63558       };
63559     } catch (...) {
63560       {
63561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63562       };
63563     }
63564   }
63565
63566 }
63567
63568
63569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
63570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63571   Dali::Dimension::Type arg2 ;
63572   SwigDirector_ViewImpl *darg = 0;
63573
63574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63575   arg2 = (Dali::Dimension::Type)jarg2;
63576   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63577   if (!darg) {
63578     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63579     return;
63580   }
63581   {
63582     try {
63583       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
63584     } catch (std::out_of_range& e) {
63585       {
63586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63587       };
63588     } catch (std::exception& e) {
63589       {
63590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63591       };
63592     } catch (Dali::DaliException e) {
63593       {
63594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63595       };
63596     } catch (...) {
63597       {
63598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63599       };
63600     }
63601   }
63602
63603 }
63604
63605
63606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
63607   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63608   float arg2 ;
63609   Dali::Dimension::Type arg3 ;
63610   SwigDirector_ViewImpl *darg = 0;
63611
63612   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63613   arg2 = (float)jarg2;
63614   arg3 = (Dali::Dimension::Type)jarg3;
63615   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63616   if (!darg) {
63617     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63618     return;
63619   }
63620   {
63621     try {
63622       (darg)->OnLayoutNegotiated(arg2,arg3);
63623     } catch (std::out_of_range& e) {
63624       {
63625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63626       };
63627     } catch (std::exception& e) {
63628       {
63629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63630       };
63631     } catch (Dali::DaliException e) {
63632       {
63633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63634       };
63635     } catch (...) {
63636       {
63637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63638       };
63639     }
63640   }
63641
63642 }
63643
63644
63645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
63646   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63647   float arg2 ;
63648   Dali::Dimension::Type arg3 ;
63649   SwigDirector_ViewImpl *darg = 0;
63650
63651   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63652   arg2 = (float)jarg2;
63653   arg3 = (Dali::Dimension::Type)jarg3;
63654   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63655   if (!darg) {
63656     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63657     return;
63658   }
63659   {
63660     try {
63661       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
63662     } catch (std::out_of_range& e) {
63663       {
63664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63665       };
63666     } catch (std::exception& e) {
63667       {
63668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63669       };
63670     } catch (Dali::DaliException e) {
63671       {
63672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63673       };
63674     } catch (...) {
63675       {
63676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63677       };
63678     }
63679   }
63680
63681 }
63682
63683
63684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
63685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63686
63687   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63688   {
63689     try {
63690       (arg1)->OnInitialize();
63691     } catch (std::out_of_range& e) {
63692       {
63693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63694       };
63695     } catch (std::exception& e) {
63696       {
63697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63698       };
63699     } catch (Dali::DaliException e) {
63700       {
63701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63702       };
63703     } catch (...) {
63704       {
63705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63706       };
63707     }
63708   }
63709
63710 }
63711
63712
63713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
63714   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63715
63716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63717   {
63718     try {
63719       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
63720     } catch (std::out_of_range& e) {
63721       {
63722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63723       };
63724     } catch (std::exception& e) {
63725       {
63726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63727       };
63728     } catch (Dali::DaliException e) {
63729       {
63730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63731       };
63732     } catch (...) {
63733       {
63734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63735       };
63736     }
63737   }
63738
63739 }
63740
63741
63742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
63743   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63744   Dali::Actor *arg2 = 0 ;
63745
63746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63747   arg2 = (Dali::Actor *)jarg2;
63748   if (!arg2) {
63749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63750     return ;
63751   }
63752   {
63753     try {
63754       (arg1)->OnControlChildAdd(*arg2);
63755     } catch (std::out_of_range& e) {
63756       {
63757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63758       };
63759     } catch (std::exception& e) {
63760       {
63761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63762       };
63763     } catch (Dali::DaliException e) {
63764       {
63765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63766       };
63767     } catch (...) {
63768       {
63769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63770       };
63771     }
63772   }
63773
63774 }
63775
63776
63777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63778   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63779   Dali::Actor *arg2 = 0 ;
63780
63781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63782   arg2 = (Dali::Actor *)jarg2;
63783   if (!arg2) {
63784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63785     return ;
63786   }
63787   {
63788     try {
63789       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
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 (Dali::DaliException e) {
63799       {
63800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63801       };
63802     } catch (...) {
63803       {
63804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63805       };
63806     }
63807   }
63808
63809 }
63810
63811
63812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
63813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63814   Dali::Actor *arg2 = 0 ;
63815
63816   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63817   arg2 = (Dali::Actor *)jarg2;
63818   if (!arg2) {
63819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63820     return ;
63821   }
63822   {
63823     try {
63824       (arg1)->OnControlChildRemove(*arg2);
63825     } catch (std::out_of_range& e) {
63826       {
63827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63828       };
63829     } catch (std::exception& e) {
63830       {
63831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63832       };
63833     } catch (Dali::DaliException e) {
63834       {
63835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63836       };
63837     } catch (...) {
63838       {
63839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63840       };
63841     }
63842   }
63843
63844 }
63845
63846
63847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63849   Dali::Actor *arg2 = 0 ;
63850
63851   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63852   arg2 = (Dali::Actor *)jarg2;
63853   if (!arg2) {
63854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63855     return ;
63856   }
63857   {
63858     try {
63859       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
63860     } catch (std::out_of_range& e) {
63861       {
63862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63863       };
63864     } catch (std::exception& e) {
63865       {
63866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63867       };
63868     } catch (Dali::DaliException e) {
63869       {
63870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63871       };
63872     } catch (...) {
63873       {
63874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63875       };
63876     }
63877   }
63878
63879 }
63880
63881
63882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
63883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63884   Dali::Toolkit::StyleManager arg2 ;
63885   Dali::StyleChange::Type arg3 ;
63886   Dali::Toolkit::StyleManager *argp2 ;
63887
63888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63889   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
63890   if (!argp2) {
63891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
63892     return ;
63893   }
63894   arg2 = *argp2;
63895   arg3 = (Dali::StyleChange::Type)jarg3;
63896   {
63897     try {
63898       (arg1)->OnStyleChange(arg2,arg3);
63899     } catch (std::out_of_range& e) {
63900       {
63901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63902       };
63903     } catch (std::exception& e) {
63904       {
63905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63906       };
63907     } catch (Dali::DaliException e) {
63908       {
63909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63910       };
63911     } catch (...) {
63912       {
63913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63914       };
63915     }
63916   }
63917
63918 }
63919
63920
63921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
63922   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63923   Dali::Toolkit::StyleManager arg2 ;
63924   Dali::StyleChange::Type arg3 ;
63925   Dali::Toolkit::StyleManager *argp2 ;
63926
63927   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63928   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
63929   if (!argp2) {
63930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
63931     return ;
63932   }
63933   arg2 = *argp2;
63934   arg3 = (Dali::StyleChange::Type)jarg3;
63935   {
63936     try {
63937       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
63938     } catch (std::out_of_range& e) {
63939       {
63940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63941       };
63942     } catch (std::exception& e) {
63943       {
63944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63945       };
63946     } catch (Dali::DaliException e) {
63947       {
63948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63949       };
63950     } catch (...) {
63951       {
63952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63953       };
63954     }
63955   }
63956
63957 }
63958
63959
63960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
63961   unsigned int jresult ;
63962   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63963   bool result;
63964
63965   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63966   {
63967     try {
63968       result = (bool)(arg1)->OnAccessibilityActivated();
63969     } catch (std::out_of_range& e) {
63970       {
63971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63972       };
63973     } catch (std::exception& e) {
63974       {
63975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63976       };
63977     } catch (Dali::DaliException e) {
63978       {
63979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63980       };
63981     } catch (...) {
63982       {
63983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63984       };
63985     }
63986   }
63987
63988   jresult = result;
63989   return jresult;
63990 }
63991
63992
63993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
63994   unsigned int jresult ;
63995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63996   bool result;
63997
63998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63999   {
64000     try {
64001       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
64002     } catch (std::out_of_range& e) {
64003       {
64004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64005       };
64006     } catch (std::exception& e) {
64007       {
64008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64009       };
64010     } catch (Dali::DaliException e) {
64011       {
64012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64013       };
64014     } catch (...) {
64015       {
64016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64017       };
64018     }
64019   }
64020
64021   jresult = result;
64022   return jresult;
64023 }
64024
64025
64026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
64027   unsigned int jresult ;
64028   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64029   Dali::PanGesture arg2 ;
64030   Dali::PanGesture *argp2 ;
64031   bool result;
64032
64033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64034   argp2 = (Dali::PanGesture *)jarg2;
64035   if (!argp2) {
64036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
64037     return 0;
64038   }
64039   arg2 = *argp2;
64040   {
64041     try {
64042       result = (bool)(arg1)->OnAccessibilityPan(arg2);
64043     } catch (std::out_of_range& e) {
64044       {
64045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64046       };
64047     } catch (std::exception& e) {
64048       {
64049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64050       };
64051     } catch (Dali::DaliException e) {
64052       {
64053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64054       };
64055     } catch (...) {
64056       {
64057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64058       };
64059     }
64060   }
64061
64062   jresult = result;
64063   return jresult;
64064 }
64065
64066
64067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64068   unsigned int jresult ;
64069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64070   Dali::PanGesture arg2 ;
64071   Dali::PanGesture *argp2 ;
64072   bool result;
64073
64074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64075   argp2 = (Dali::PanGesture *)jarg2;
64076   if (!argp2) {
64077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
64078     return 0;
64079   }
64080   arg2 = *argp2;
64081   {
64082     try {
64083       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
64084     } catch (std::out_of_range& e) {
64085       {
64086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64087       };
64088     } catch (std::exception& e) {
64089       {
64090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64091       };
64092     } catch (Dali::DaliException e) {
64093       {
64094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64095       };
64096     } catch (...) {
64097       {
64098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64099       };
64100     }
64101   }
64102
64103   jresult = result;
64104   return jresult;
64105 }
64106
64107
64108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
64109   unsigned int jresult ;
64110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64111   Dali::TouchEvent *arg2 = 0 ;
64112   bool result;
64113
64114   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64115   arg2 = (Dali::TouchEvent *)jarg2;
64116   if (!arg2) {
64117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64118     return 0;
64119   }
64120   {
64121     try {
64122       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
64123     } catch (std::out_of_range& e) {
64124       {
64125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64126       };
64127     } catch (std::exception& e) {
64128       {
64129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64130       };
64131     } catch (Dali::DaliException e) {
64132       {
64133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64134       };
64135     } catch (...) {
64136       {
64137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64138       };
64139     }
64140   }
64141
64142   jresult = result;
64143   return jresult;
64144 }
64145
64146
64147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64148   unsigned int jresult ;
64149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64150   Dali::TouchEvent *arg2 = 0 ;
64151   bool result;
64152
64153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64154   arg2 = (Dali::TouchEvent *)jarg2;
64155   if (!arg2) {
64156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64157     return 0;
64158   }
64159   {
64160     try {
64161       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
64162     } catch (std::out_of_range& e) {
64163       {
64164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64165       };
64166     } catch (std::exception& e) {
64167       {
64168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64169       };
64170     } catch (Dali::DaliException e) {
64171       {
64172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64173       };
64174     } catch (...) {
64175       {
64176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64177       };
64178     }
64179   }
64180
64181   jresult = result;
64182   return jresult;
64183 }
64184
64185
64186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
64187   unsigned int jresult ;
64188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64189   bool arg2 ;
64190   bool result;
64191
64192   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64193   arg2 = jarg2 ? true : false;
64194   {
64195     try {
64196       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
64197     } catch (std::out_of_range& e) {
64198       {
64199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64200       };
64201     } catch (std::exception& e) {
64202       {
64203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64204       };
64205     } catch (Dali::DaliException e) {
64206       {
64207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64208       };
64209     } catch (...) {
64210       {
64211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64212       };
64213     }
64214   }
64215
64216   jresult = result;
64217   return jresult;
64218 }
64219
64220
64221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
64222   unsigned int jresult ;
64223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64224   bool arg2 ;
64225   bool result;
64226
64227   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64228   arg2 = jarg2 ? true : false;
64229   {
64230     try {
64231       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
64232     } catch (std::out_of_range& e) {
64233       {
64234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64235       };
64236     } catch (std::exception& e) {
64237       {
64238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64239       };
64240     } catch (Dali::DaliException e) {
64241       {
64242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64243       };
64244     } catch (...) {
64245       {
64246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64247       };
64248     }
64249   }
64250
64251   jresult = result;
64252   return jresult;
64253 }
64254
64255
64256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
64257   unsigned int jresult ;
64258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64259   bool result;
64260
64261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64262   {
64263     try {
64264       result = (bool)(arg1)->OnAccessibilityZoom();
64265     } catch (std::out_of_range& e) {
64266       {
64267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64268       };
64269     } catch (std::exception& e) {
64270       {
64271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64272       };
64273     } catch (Dali::DaliException e) {
64274       {
64275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64276       };
64277     } catch (...) {
64278       {
64279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64280       };
64281     }
64282   }
64283
64284   jresult = result;
64285   return jresult;
64286 }
64287
64288
64289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
64290   unsigned int jresult ;
64291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64292   bool result;
64293
64294   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64295   {
64296     try {
64297       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
64298     } catch (std::out_of_range& e) {
64299       {
64300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64301       };
64302     } catch (std::exception& e) {
64303       {
64304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64305       };
64306     } catch (Dali::DaliException e) {
64307       {
64308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64309       };
64310     } catch (...) {
64311       {
64312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64313       };
64314     }
64315   }
64316
64317   jresult = result;
64318   return jresult;
64319 }
64320
64321
64322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
64323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64324
64325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64326   {
64327     try {
64328       (arg1)->OnKeyInputFocusGained();
64329     } catch (std::out_of_range& e) {
64330       {
64331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64332       };
64333     } catch (std::exception& e) {
64334       {
64335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64336       };
64337     } catch (Dali::DaliException e) {
64338       {
64339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64340       };
64341     } catch (...) {
64342       {
64343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64344       };
64345     }
64346   }
64347
64348 }
64349
64350
64351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
64352   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64353
64354   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64355   {
64356     try {
64357       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
64358     } catch (std::out_of_range& e) {
64359       {
64360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64361       };
64362     } catch (std::exception& e) {
64363       {
64364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64365       };
64366     } catch (Dali::DaliException e) {
64367       {
64368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64369       };
64370     } catch (...) {
64371       {
64372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64373       };
64374     }
64375   }
64376
64377 }
64378
64379
64380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
64381   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64382
64383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64384   {
64385     try {
64386       (arg1)->OnKeyInputFocusLost();
64387     } catch (std::out_of_range& e) {
64388       {
64389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64390       };
64391     } catch (std::exception& e) {
64392       {
64393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64394       };
64395     } catch (Dali::DaliException e) {
64396       {
64397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64398       };
64399     } catch (...) {
64400       {
64401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64402       };
64403     }
64404   }
64405
64406 }
64407
64408
64409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
64410   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64411
64412   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64413   {
64414     try {
64415       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
64416     } catch (std::out_of_range& e) {
64417       {
64418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64419       };
64420     } catch (std::exception& e) {
64421       {
64422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64423       };
64424     } catch (Dali::DaliException e) {
64425       {
64426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64427       };
64428     } catch (...) {
64429       {
64430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64431       };
64432     }
64433   }
64434
64435 }
64436
64437
64438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
64439   void * jresult ;
64440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64441   Dali::Actor arg2 ;
64442   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
64443   bool arg4 ;
64444   Dali::Actor *argp2 ;
64445   Dali::Actor result;
64446
64447   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64448   argp2 = (Dali::Actor *)jarg2;
64449   if (!argp2) {
64450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64451     return 0;
64452   }
64453   arg2 = *argp2;
64454   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
64455   arg4 = jarg4 ? true : false;
64456   {
64457     try {
64458       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
64459     } catch (std::out_of_range& e) {
64460       {
64461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64462       };
64463     } catch (std::exception& e) {
64464       {
64465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64466       };
64467     } catch (Dali::DaliException e) {
64468       {
64469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64470       };
64471     } catch (...) {
64472       {
64473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64474       };
64475     }
64476   }
64477
64478   jresult = new Dali::Actor((const Dali::Actor &)result);
64479   return jresult;
64480 }
64481
64482
64483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
64484   void * jresult ;
64485   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64486   Dali::Actor arg2 ;
64487   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
64488   bool arg4 ;
64489   Dali::Actor *argp2 ;
64490   Dali::Actor result;
64491
64492   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64493   argp2 = (Dali::Actor *)jarg2;
64494   if (!argp2) {
64495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64496     return 0;
64497   }
64498   arg2 = *argp2;
64499   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
64500   arg4 = jarg4 ? true : false;
64501   {
64502     try {
64503       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
64504     } catch (std::out_of_range& e) {
64505       {
64506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64507       };
64508     } catch (std::exception& e) {
64509       {
64510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64511       };
64512     } catch (Dali::DaliException e) {
64513       {
64514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64515       };
64516     } catch (...) {
64517       {
64518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64519       };
64520     }
64521   }
64522
64523   jresult = new Dali::Actor((const Dali::Actor &)result);
64524   return jresult;
64525 }
64526
64527
64528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
64529   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64530   Dali::Actor arg2 ;
64531   Dali::Actor *argp2 ;
64532
64533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64534   argp2 = (Dali::Actor *)jarg2;
64535   if (!argp2) {
64536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64537     return ;
64538   }
64539   arg2 = *argp2;
64540   {
64541     try {
64542       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
64543     } catch (std::out_of_range& e) {
64544       {
64545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64546       };
64547     } catch (std::exception& e) {
64548       {
64549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64550       };
64551     } catch (Dali::DaliException e) {
64552       {
64553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64554       };
64555     } catch (...) {
64556       {
64557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64558       };
64559     }
64560   }
64561
64562 }
64563
64564
64565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64567   Dali::Actor arg2 ;
64568   Dali::Actor *argp2 ;
64569
64570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64571   argp2 = (Dali::Actor *)jarg2;
64572   if (!argp2) {
64573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64574     return ;
64575   }
64576   arg2 = *argp2;
64577   {
64578     try {
64579       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
64580     } catch (std::out_of_range& e) {
64581       {
64582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64583       };
64584     } catch (std::exception& e) {
64585       {
64586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64587       };
64588     } catch (Dali::DaliException e) {
64589       {
64590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64591       };
64592     } catch (...) {
64593       {
64594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64595       };
64596     }
64597   }
64598
64599 }
64600
64601
64602 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
64603   unsigned int jresult ;
64604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64605   bool result;
64606
64607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64608   {
64609     try {
64610       result = (bool)(arg1)->OnKeyboardEnter();
64611     } catch (std::out_of_range& e) {
64612       {
64613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64614       };
64615     } catch (std::exception& e) {
64616       {
64617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64618       };
64619     } catch (Dali::DaliException e) {
64620       {
64621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64622       };
64623     } catch (...) {
64624       {
64625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64626       };
64627     }
64628   }
64629
64630   jresult = result;
64631   return jresult;
64632 }
64633
64634
64635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
64636   unsigned int jresult ;
64637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64638   bool result;
64639
64640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64641   {
64642     try {
64643       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
64644     } catch (std::out_of_range& e) {
64645       {
64646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64647       };
64648     } catch (std::exception& e) {
64649       {
64650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64651       };
64652     } catch (Dali::DaliException e) {
64653       {
64654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64655       };
64656     } catch (...) {
64657       {
64658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64659       };
64660     }
64661   }
64662
64663   jresult = result;
64664   return jresult;
64665 }
64666
64667
64668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
64669   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64670   Dali::PinchGesture *arg2 = 0 ;
64671
64672   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64673   arg2 = (Dali::PinchGesture *)jarg2;
64674   if (!arg2) {
64675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
64676     return ;
64677   }
64678   {
64679     try {
64680       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
64681     } catch (std::out_of_range& e) {
64682       {
64683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64684       };
64685     } catch (std::exception& e) {
64686       {
64687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64688       };
64689     } catch (Dali::DaliException e) {
64690       {
64691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64692       };
64693     } catch (...) {
64694       {
64695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64696       };
64697     }
64698   }
64699
64700 }
64701
64702
64703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64704   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64705   Dali::PinchGesture *arg2 = 0 ;
64706
64707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64708   arg2 = (Dali::PinchGesture *)jarg2;
64709   if (!arg2) {
64710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
64711     return ;
64712   }
64713   {
64714     try {
64715       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
64716     } catch (std::out_of_range& e) {
64717       {
64718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64719       };
64720     } catch (std::exception& e) {
64721       {
64722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64723       };
64724     } catch (Dali::DaliException e) {
64725       {
64726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64727       };
64728     } catch (...) {
64729       {
64730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64731       };
64732     }
64733   }
64734
64735 }
64736
64737
64738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
64739   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64740   Dali::PanGesture *arg2 = 0 ;
64741
64742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64743   arg2 = (Dali::PanGesture *)jarg2;
64744   if (!arg2) {
64745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
64746     return ;
64747   }
64748   {
64749     try {
64750       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
64751     } catch (std::out_of_range& e) {
64752       {
64753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64754       };
64755     } catch (std::exception& e) {
64756       {
64757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64758       };
64759     } catch (Dali::DaliException e) {
64760       {
64761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64762       };
64763     } catch (...) {
64764       {
64765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64766       };
64767     }
64768   }
64769
64770 }
64771
64772
64773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64775   Dali::PanGesture *arg2 = 0 ;
64776
64777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64778   arg2 = (Dali::PanGesture *)jarg2;
64779   if (!arg2) {
64780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
64781     return ;
64782   }
64783   {
64784     try {
64785       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
64786     } catch (std::out_of_range& e) {
64787       {
64788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64789       };
64790     } catch (std::exception& e) {
64791       {
64792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64793       };
64794     } catch (Dali::DaliException e) {
64795       {
64796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64797       };
64798     } catch (...) {
64799       {
64800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64801       };
64802     }
64803   }
64804
64805 }
64806
64807
64808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
64809   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64810   Dali::TapGesture *arg2 = 0 ;
64811
64812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64813   arg2 = (Dali::TapGesture *)jarg2;
64814   if (!arg2) {
64815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
64816     return ;
64817   }
64818   {
64819     try {
64820       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
64821     } catch (std::out_of_range& e) {
64822       {
64823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64824       };
64825     } catch (std::exception& e) {
64826       {
64827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64828       };
64829     } catch (Dali::DaliException e) {
64830       {
64831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64832       };
64833     } catch (...) {
64834       {
64835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64836       };
64837     }
64838   }
64839
64840 }
64841
64842
64843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64845   Dali::TapGesture *arg2 = 0 ;
64846
64847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64848   arg2 = (Dali::TapGesture *)jarg2;
64849   if (!arg2) {
64850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
64851     return ;
64852   }
64853   {
64854     try {
64855       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
64856     } catch (std::out_of_range& e) {
64857       {
64858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64859       };
64860     } catch (std::exception& e) {
64861       {
64862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64863       };
64864     } catch (Dali::DaliException e) {
64865       {
64866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64867       };
64868     } catch (...) {
64869       {
64870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64871       };
64872     }
64873   }
64874
64875 }
64876
64877
64878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
64879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64880   Dali::LongPressGesture *arg2 = 0 ;
64881
64882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64883   arg2 = (Dali::LongPressGesture *)jarg2;
64884   if (!arg2) {
64885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
64886     return ;
64887   }
64888   {
64889     try {
64890       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
64891     } catch (std::out_of_range& e) {
64892       {
64893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64894       };
64895     } catch (std::exception& e) {
64896       {
64897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64898       };
64899     } catch (Dali::DaliException e) {
64900       {
64901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64902       };
64903     } catch (...) {
64904       {
64905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64906       };
64907     }
64908   }
64909
64910 }
64911
64912
64913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64915   Dali::LongPressGesture *arg2 = 0 ;
64916
64917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64918   arg2 = (Dali::LongPressGesture *)jarg2;
64919   if (!arg2) {
64920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
64921     return ;
64922   }
64923   {
64924     try {
64925       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
64926     } catch (std::out_of_range& e) {
64927       {
64928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64929       };
64930     } catch (std::exception& e) {
64931       {
64932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64933       };
64934     } catch (Dali::DaliException e) {
64935       {
64936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64937       };
64938     } catch (...) {
64939       {
64940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64941       };
64942     }
64943   }
64944
64945 }
64946
64947
64948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
64949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64950   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
64951   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
64952
64953   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64954   arg2 = (Dali::SlotObserver *)jarg2;
64955   arg3 = (Dali::CallbackBase *)jarg3;
64956   {
64957     try {
64958       (arg1)->SignalConnected(arg2,arg3);
64959     } catch (std::out_of_range& e) {
64960       {
64961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64962       };
64963     } catch (std::exception& e) {
64964       {
64965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64966       };
64967     } catch (Dali::DaliException e) {
64968       {
64969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64970       };
64971     } catch (...) {
64972       {
64973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64974       };
64975     }
64976   }
64977
64978 }
64979
64980
64981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64982   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64983   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
64984   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
64985
64986   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64987   arg2 = (Dali::SlotObserver *)jarg2;
64988   arg3 = (Dali::CallbackBase *)jarg3;
64989   {
64990     try {
64991       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
64992     } catch (std::out_of_range& e) {
64993       {
64994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64995       };
64996     } catch (std::exception& e) {
64997       {
64998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64999       };
65000     } catch (Dali::DaliException e) {
65001       {
65002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65003       };
65004     } catch (...) {
65005       {
65006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65007       };
65008     }
65009   }
65010
65011 }
65012
65013
65014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
65015   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65016   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
65017   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
65018
65019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65020   arg2 = (Dali::SlotObserver *)jarg2;
65021   arg3 = (Dali::CallbackBase *)jarg3;
65022   {
65023     try {
65024       (arg1)->SignalDisconnected(arg2,arg3);
65025     } catch (std::out_of_range& e) {
65026       {
65027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65028       };
65029     } catch (std::exception& e) {
65030       {
65031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65032       };
65033     } catch (Dali::DaliException e) {
65034       {
65035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65036       };
65037     } catch (...) {
65038       {
65039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65040       };
65041     }
65042   }
65043
65044 }
65045
65046
65047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65048   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65049   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
65050   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
65051
65052   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65053   arg2 = (Dali::SlotObserver *)jarg2;
65054   arg3 = (Dali::CallbackBase *)jarg3;
65055   {
65056     try {
65057       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
65058     } catch (std::out_of_range& e) {
65059       {
65060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65061       };
65062     } catch (std::exception& e) {
65063       {
65064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65065       };
65066     } catch (Dali::DaliException e) {
65067       {
65068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65069       };
65070     } catch (...) {
65071       {
65072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65073       };
65074     }
65075   }
65076
65077 }
65078
65079
65080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_director_connect(void *objarg, SwigDirector_ViewImpl::SWIG_Callback0_t callback0, SwigDirector_ViewImpl::SWIG_Callback1_t callback1, SwigDirector_ViewImpl::SWIG_Callback2_t callback2, SwigDirector_ViewImpl::SWIG_Callback3_t callback3, SwigDirector_ViewImpl::SWIG_Callback4_t callback4, SwigDirector_ViewImpl::SWIG_Callback5_t callback5, SwigDirector_ViewImpl::SWIG_Callback6_t callback6, SwigDirector_ViewImpl::SWIG_Callback7_t callback7, SwigDirector_ViewImpl::SWIG_Callback8_t callback8, SwigDirector_ViewImpl::SWIG_Callback9_t callback9, SwigDirector_ViewImpl::SWIG_Callback10_t callback10, SwigDirector_ViewImpl::SWIG_Callback11_t callback11, SwigDirector_ViewImpl::SWIG_Callback12_t callback12, SwigDirector_ViewImpl::SWIG_Callback13_t callback13, SwigDirector_ViewImpl::SWIG_Callback14_t callback14, SwigDirector_ViewImpl::SWIG_Callback15_t callback15, SwigDirector_ViewImpl::SWIG_Callback16_t callback16, SwigDirector_ViewImpl::SWIG_Callback17_t callback17, SwigDirector_ViewImpl::SWIG_Callback18_t callback18, SwigDirector_ViewImpl::SWIG_Callback19_t callback19, SwigDirector_ViewImpl::SWIG_Callback20_t callback20, SwigDirector_ViewImpl::SWIG_Callback21_t callback21, SwigDirector_ViewImpl::SWIG_Callback22_t callback22, SwigDirector_ViewImpl::SWIG_Callback23_t callback23, SwigDirector_ViewImpl::SWIG_Callback24_t callback24, SwigDirector_ViewImpl::SWIG_Callback25_t callback25, SwigDirector_ViewImpl::SWIG_Callback26_t callback26, SwigDirector_ViewImpl::SWIG_Callback27_t callback27, SwigDirector_ViewImpl::SWIG_Callback28_t callback28, SwigDirector_ViewImpl::SWIG_Callback29_t callback29, SwigDirector_ViewImpl::SWIG_Callback30_t callback30, SwigDirector_ViewImpl::SWIG_Callback31_t callback31, SwigDirector_ViewImpl::SWIG_Callback32_t callback32, SwigDirector_ViewImpl::SWIG_Callback33_t callback33, SwigDirector_ViewImpl::SWIG_Callback34_t callback34, SwigDirector_ViewImpl::SWIG_Callback35_t callback35, SwigDirector_ViewImpl::SWIG_Callback36_t callback36, SwigDirector_ViewImpl::SWIG_Callback37_t callback37, SwigDirector_ViewImpl::SWIG_Callback38_t callback38, SwigDirector_ViewImpl::SWIG_Callback39_t callback39, SwigDirector_ViewImpl::SWIG_Callback40_t callback40) {
65081   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
65082   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
65083   if (director) {
65084     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback22, callback23, callback24, callback25, callback26, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
65085   }
65086 }
65087
65088
65089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
65090   void * jresult ;
65091   Dali::Toolkit::Control *arg1 = 0 ;
65092   Dali::Toolkit::Internal::Control *result = 0 ;
65093
65094   arg1 = (Dali::Toolkit::Control *)jarg1;
65095   if (!arg1) {
65096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
65097     return 0;
65098   }
65099   {
65100     try {
65101       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
65102     } catch (std::out_of_range& e) {
65103       {
65104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65105       };
65106     } catch (std::exception& e) {
65107       {
65108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65109       };
65110     } catch (Dali::DaliException e) {
65111       {
65112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65113       };
65114     } catch (...) {
65115       {
65116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65117       };
65118     }
65119   }
65120
65121   jresult = (void *)result;
65122   return jresult;
65123 }
65124
65125
65126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
65127   int jresult ;
65128   int result;
65129
65130   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
65131   jresult = (int)result;
65132   return jresult;
65133 }
65134
65135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
65136   int jresult ;
65137   int result;
65138
65139   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
65140   jresult = (int)result;
65141   return jresult;
65142 }
65143
65144
65145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
65146   int jresult ;
65147   int result;
65148
65149   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
65150   jresult = (int)result;
65151   return jresult;
65152 }
65153
65154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
65155   int jresult ;
65156   int result;
65157
65158   result = (int)Dali::Toolkit::Control::Property::MARGIN;
65159   jresult = (int)result;
65160   return jresult;
65161 }
65162
65163
65164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
65165   int jresult ;
65166   int result;
65167
65168   result = (int)Dali::Toolkit::Control::Property::PADDING;
65169   jresult = (int)result;
65170   return jresult;
65171 }
65172
65173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
65174   int jresult ;
65175   int result;
65176
65177   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
65178   jresult = (int)result;
65179   return jresult;
65180 }
65181
65182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
65183   void * jresult ;
65184   Dali::Toolkit::Control::Property *result = 0 ;
65185
65186   {
65187     try {
65188       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
65189     } catch (std::out_of_range& e) {
65190       {
65191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65192       };
65193     } catch (std::exception& e) {
65194       {
65195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65196       };
65197     } catch (Dali::DaliException e) {
65198       {
65199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65200       };
65201     } catch (...) {
65202       {
65203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65204       };
65205     }
65206   }
65207
65208   jresult = (void *)result;
65209   return jresult;
65210 }
65211
65212
65213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
65214   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
65215
65216   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
65217   {
65218     try {
65219       delete arg1;
65220     } catch (std::out_of_range& e) {
65221       {
65222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65223       };
65224     } catch (std::exception& e) {
65225       {
65226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65227       };
65228     } catch (Dali::DaliException e) {
65229       {
65230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65231       };
65232     } catch (...) {
65233       {
65234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65235       };
65236     }
65237   }
65238
65239 }
65240
65241
65242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
65243   void * jresult ;
65244   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
65245
65246   {
65247     try {
65248       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
65249     } catch (std::out_of_range& e) {
65250       {
65251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65252       };
65253     } catch (std::exception& e) {
65254       {
65255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65256       };
65257     } catch (Dali::DaliException e) {
65258       {
65259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65260       };
65261     } catch (...) {
65262       {
65263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65264       };
65265     }
65266   }
65267
65268   jresult = (void *)result;
65269   return jresult;
65270 }
65271
65272
65273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
65274   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
65275
65276   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
65277   {
65278     try {
65279       delete arg1;
65280     } catch (std::out_of_range& e) {
65281       {
65282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65283       };
65284     } catch (std::exception& e) {
65285       {
65286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65287       };
65288     } catch (Dali::DaliException e) {
65289       {
65290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65291       };
65292     } catch (...) {
65293       {
65294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65295       };
65296     }
65297   }
65298
65299 }
65300
65301
65302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
65303   void * jresult ;
65304   Dali::Toolkit::Control result;
65305
65306   {
65307     try {
65308       result = Dali::Toolkit::Control::New();
65309     } catch (std::out_of_range& e) {
65310       {
65311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65312       };
65313     } catch (std::exception& e) {
65314       {
65315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65316       };
65317     } catch (Dali::DaliException e) {
65318       {
65319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65320       };
65321     } catch (...) {
65322       {
65323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65324       };
65325     }
65326   }
65327
65328   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
65329   return jresult;
65330 }
65331
65332
65333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
65334   void * jresult ;
65335   Dali::Toolkit::Control *result = 0 ;
65336
65337   {
65338     try {
65339       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
65340     } catch (std::out_of_range& e) {
65341       {
65342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65343       };
65344     } catch (std::exception& e) {
65345       {
65346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65347       };
65348     } catch (Dali::DaliException e) {
65349       {
65350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65351       };
65352     } catch (...) {
65353       {
65354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65355       };
65356     }
65357   }
65358
65359   jresult = (void *)result;
65360   return jresult;
65361 }
65362
65363
65364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
65365   void * jresult ;
65366   Dali::Toolkit::Control *arg1 = 0 ;
65367   Dali::Toolkit::Control *result = 0 ;
65368
65369   arg1 = (Dali::Toolkit::Control *)jarg1;
65370   if (!arg1) {
65371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
65372     return 0;
65373   }
65374   {
65375     try {
65376       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
65377     } catch (std::out_of_range& e) {
65378       {
65379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65380       };
65381     } catch (std::exception& e) {
65382       {
65383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65384       };
65385     } catch (Dali::DaliException e) {
65386       {
65387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65388       };
65389     } catch (...) {
65390       {
65391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65392       };
65393     }
65394   }
65395
65396   jresult = (void *)result;
65397   return jresult;
65398 }
65399
65400
65401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
65402   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65403
65404   arg1 = (Dali::Toolkit::Control *)jarg1;
65405   {
65406     try {
65407       delete arg1;
65408     } catch (std::out_of_range& e) {
65409       {
65410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65411       };
65412     } catch (std::exception& e) {
65413       {
65414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65415       };
65416     } catch (Dali::DaliException e) {
65417       {
65418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65419       };
65420     } catch (...) {
65421       {
65422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65423       };
65424     }
65425   }
65426
65427 }
65428
65429
65430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
65431   void * jresult ;
65432   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65433   Dali::Toolkit::Control *arg2 = 0 ;
65434   Dali::Toolkit::Control *result = 0 ;
65435
65436   arg1 = (Dali::Toolkit::Control *)jarg1;
65437   arg2 = (Dali::Toolkit::Control *)jarg2;
65438   if (!arg2) {
65439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
65440     return 0;
65441   }
65442   {
65443     try {
65444       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
65445     } catch (std::out_of_range& e) {
65446       {
65447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65448       };
65449     } catch (std::exception& e) {
65450       {
65451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65452       };
65453     } catch (Dali::DaliException e) {
65454       {
65455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65456       };
65457     } catch (...) {
65458       {
65459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65460       };
65461     }
65462   }
65463
65464   jresult = (void *)result;
65465   return jresult;
65466 }
65467
65468
65469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
65470   void * jresult ;
65471   Dali::BaseHandle arg1 ;
65472   Dali::BaseHandle *argp1 ;
65473   Dali::Toolkit::Control result;
65474
65475   argp1 = (Dali::BaseHandle *)jarg1;
65476   if (!argp1) {
65477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65478     return 0;
65479   }
65480   arg1 = *argp1;
65481   {
65482     try {
65483       result = Dali::Toolkit::Control::DownCast(arg1);
65484     } catch (std::out_of_range& e) {
65485       {
65486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65487       };
65488     } catch (std::exception& e) {
65489       {
65490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65491       };
65492     } catch (Dali::DaliException e) {
65493       {
65494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65495       };
65496     } catch (...) {
65497       {
65498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65499       };
65500     }
65501   }
65502
65503   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
65504   return jresult;
65505 }
65506
65507
65508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
65509   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65510
65511   arg1 = (Dali::Toolkit::Control *)jarg1;
65512   {
65513     try {
65514       (arg1)->SetKeyInputFocus();
65515     } catch (std::out_of_range& e) {
65516       {
65517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65518       };
65519     } catch (std::exception& e) {
65520       {
65521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65522       };
65523     } catch (Dali::DaliException e) {
65524       {
65525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65526       };
65527     } catch (...) {
65528       {
65529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65530       };
65531     }
65532   }
65533
65534 }
65535
65536
65537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
65538   unsigned int jresult ;
65539   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65540   bool result;
65541
65542   arg1 = (Dali::Toolkit::Control *)jarg1;
65543   {
65544     try {
65545       result = (bool)(arg1)->HasKeyInputFocus();
65546     } catch (std::out_of_range& e) {
65547       {
65548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65549       };
65550     } catch (std::exception& e) {
65551       {
65552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65553       };
65554     } catch (Dali::DaliException e) {
65555       {
65556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65557       };
65558     } catch (...) {
65559       {
65560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65561       };
65562     }
65563   }
65564
65565   jresult = result;
65566   return jresult;
65567 }
65568
65569
65570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
65571   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65572
65573   arg1 = (Dali::Toolkit::Control *)jarg1;
65574   {
65575     try {
65576       (arg1)->ClearKeyInputFocus();
65577     } catch (std::out_of_range& e) {
65578       {
65579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65580       };
65581     } catch (std::exception& e) {
65582       {
65583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65584       };
65585     } catch (Dali::DaliException e) {
65586       {
65587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65588       };
65589     } catch (...) {
65590       {
65591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65592       };
65593     }
65594   }
65595
65596 }
65597
65598
65599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
65600   void * jresult ;
65601   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65602   Dali::PinchGestureDetector result;
65603
65604   arg1 = (Dali::Toolkit::Control *)jarg1;
65605   {
65606     try {
65607       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
65608     } catch (std::out_of_range& e) {
65609       {
65610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65611       };
65612     } catch (std::exception& e) {
65613       {
65614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65615       };
65616     } catch (Dali::DaliException e) {
65617       {
65618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65619       };
65620     } catch (...) {
65621       {
65622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65623       };
65624     }
65625   }
65626
65627   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
65628   return jresult;
65629 }
65630
65631
65632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
65633   void * jresult ;
65634   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65635   Dali::PanGestureDetector result;
65636
65637   arg1 = (Dali::Toolkit::Control *)jarg1;
65638   {
65639     try {
65640       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
65641     } catch (std::out_of_range& e) {
65642       {
65643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65644       };
65645     } catch (std::exception& e) {
65646       {
65647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65648       };
65649     } catch (Dali::DaliException e) {
65650       {
65651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65652       };
65653     } catch (...) {
65654       {
65655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65656       };
65657     }
65658   }
65659
65660   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
65661   return jresult;
65662 }
65663
65664
65665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
65666   void * jresult ;
65667   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65668   Dali::TapGestureDetector result;
65669
65670   arg1 = (Dali::Toolkit::Control *)jarg1;
65671   {
65672     try {
65673       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
65674     } catch (std::out_of_range& e) {
65675       {
65676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65677       };
65678     } catch (std::exception& e) {
65679       {
65680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65681       };
65682     } catch (Dali::DaliException e) {
65683       {
65684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65685       };
65686     } catch (...) {
65687       {
65688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65689       };
65690     }
65691   }
65692
65693   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
65694   return jresult;
65695 }
65696
65697
65698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
65699   void * jresult ;
65700   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65701   Dali::LongPressGestureDetector result;
65702
65703   arg1 = (Dali::Toolkit::Control *)jarg1;
65704   {
65705     try {
65706       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
65707     } catch (std::out_of_range& e) {
65708       {
65709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65710       };
65711     } catch (std::exception& e) {
65712       {
65713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65714       };
65715     } catch (Dali::DaliException e) {
65716       {
65717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65718       };
65719     } catch (...) {
65720       {
65721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65722       };
65723     }
65724   }
65725
65726   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
65727   return jresult;
65728 }
65729
65730
65731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
65732   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65733   std::string *arg2 = 0 ;
65734
65735   arg1 = (Dali::Toolkit::Control *)jarg1;
65736   if (!jarg2) {
65737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65738     return ;
65739   }
65740   std::string arg2_str(jarg2);
65741   arg2 = &arg2_str;
65742   {
65743     try {
65744       (arg1)->SetStyleName((std::string const &)*arg2);
65745     } catch (std::out_of_range& e) {
65746       {
65747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65748       };
65749     } catch (std::exception& e) {
65750       {
65751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65752       };
65753     } catch (Dali::DaliException e) {
65754       {
65755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65756       };
65757     } catch (...) {
65758       {
65759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65760       };
65761     }
65762   }
65763
65764
65765   //argout typemap for const std::string&
65766
65767 }
65768
65769
65770 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
65771   char * jresult ;
65772   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65773   std::string *result = 0 ;
65774
65775   arg1 = (Dali::Toolkit::Control *)jarg1;
65776   {
65777     try {
65778       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
65779     } catch (std::out_of_range& e) {
65780       {
65781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65782       };
65783     } catch (std::exception& e) {
65784       {
65785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65786       };
65787     } catch (Dali::DaliException e) {
65788       {
65789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65790       };
65791     } catch (...) {
65792       {
65793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65794       };
65795     }
65796   }
65797
65798   jresult = SWIG_csharp_string_callback(result->c_str());
65799   return jresult;
65800 }
65801
65802
65803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
65804   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65805   Dali::Vector4 *arg2 = 0 ;
65806
65807   arg1 = (Dali::Toolkit::Control *)jarg1;
65808   arg2 = (Dali::Vector4 *)jarg2;
65809   if (!arg2) {
65810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
65811     return ;
65812   }
65813   {
65814     try {
65815       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
65816     } catch (std::out_of_range& e) {
65817       {
65818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65819       };
65820     } catch (std::exception& e) {
65821       {
65822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65823       };
65824     } catch (Dali::DaliException e) {
65825       {
65826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65827       };
65828     } catch (...) {
65829       {
65830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65831       };
65832     }
65833   }
65834
65835 }
65836
65837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
65838   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65839
65840   arg1 = (Dali::Toolkit::Control *)jarg1;
65841   {
65842     try {
65843       (arg1)->ClearBackground();
65844     } catch (std::out_of_range& e) {
65845       {
65846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65847       };
65848     } catch (std::exception& e) {
65849       {
65850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65851       };
65852     } catch (Dali::DaliException e) {
65853       {
65854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65855       };
65856     } catch (...) {
65857       {
65858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65859       };
65860     }
65861   }
65862
65863 }
65864
65865
65866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
65867   void * jresult ;
65868   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65869   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
65870
65871   arg1 = (Dali::Toolkit::Control *)jarg1;
65872   {
65873     try {
65874       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
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 = (void *)result;
65895   return jresult;
65896 }
65897
65898
65899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
65900   void * jresult ;
65901   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65902   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
65903
65904   arg1 = (Dali::Toolkit::Control *)jarg1;
65905   {
65906     try {
65907       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
65908     } catch (std::out_of_range& e) {
65909       {
65910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65911       };
65912     } catch (std::exception& e) {
65913       {
65914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65915       };
65916     } catch (Dali::DaliException e) {
65917       {
65918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65919       };
65920     } catch (...) {
65921       {
65922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65923       };
65924     }
65925   }
65926
65927   jresult = (void *)result;
65928   return jresult;
65929 }
65930
65931
65932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
65933   void * jresult ;
65934   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65935   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
65936
65937   arg1 = (Dali::Toolkit::Control *)jarg1;
65938   {
65939     try {
65940       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
65941     } catch (std::out_of_range& e) {
65942       {
65943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65944       };
65945     } catch (std::exception& e) {
65946       {
65947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65948       };
65949     } catch (Dali::DaliException e) {
65950       {
65951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65952       };
65953     } catch (...) {
65954       {
65955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65956       };
65957     }
65958   }
65959
65960   jresult = (void *)result;
65961   return jresult;
65962 }
65963
65964
65965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
65966   void * jresult ;
65967   Dali::Toolkit::Internal::Control *arg1 = 0 ;
65968   Dali::Toolkit::Control *result = 0 ;
65969
65970   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65971   if (!arg1) {
65972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
65973     return 0;
65974   }
65975   {
65976     try {
65977       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
65978     } catch (std::out_of_range& e) {
65979       {
65980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65981       };
65982     } catch (std::exception& e) {
65983       {
65984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65985       };
65986     } catch (Dali::DaliException e) {
65987       {
65988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65989       };
65990     } catch (...) {
65991       {
65992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65993       };
65994     }
65995   }
65996
65997   jresult = (void *)result;
65998   return jresult;
65999 }
66000
66001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
66002 {
66003   int jresult;
66004   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66005   arg1 = (Dali::Toolkit::Control *)jarg1;
66006
66007   if (!arg1) {
66008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66009     return 0;
66010   }
66011
66012   Dali::Property::Index arg2 = 0 ;
66013   arg2 = (Dali::Property::Index)jarg2;
66014
66015   Toolkit::Visual::ResourceStatus result;
66016   {
66017     try {
66018       result = arg1->GetVisualResourceStatus(arg2);
66019     } catch (std::out_of_range& e) {
66020       {
66021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66022       };
66023     } catch (std::exception& e) {
66024       {
66025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66026       };
66027     } catch (...) {
66028       {
66029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66030       };
66031     }
66032   }
66033   jresult = (int)(result);
66034   return jresult;
66035 }
66036
66037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
66038 {
66039   void * jresult;
66040   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66041   arg1 = (Dali::Toolkit::Control *)jarg1;
66042
66043   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
66044
66045   Dali::Toolkit::TransitionData *arg2 = 0 ;
66046   Dali::Animation result;
66047
66048   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
66049   if (!arg2) {
66050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
66051     return 0;
66052   }
66053   {
66054     try {
66055       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
66056     } catch (std::out_of_range& e) {
66057       {
66058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66059       };
66060     } catch (std::exception& e) {
66061       {
66062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66063       };
66064     } catch (Dali::DaliException e) {
66065       {
66066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66067       };
66068     } catch (...) {
66069       {
66070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66071       };
66072     }
66073   }
66074
66075   jresult = new Dali::Animation((const Dali::Animation &)result);
66076   return jresult;
66077 }
66078
66079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
66080 {
66081   Dali::Toolkit::Control arg1;
66082   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
66083
66084   if (!argp1) {
66085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66086   }
66087   arg1 = *argp1;
66088
66089   Dali::Property::Index arg2 = 0 ;
66090   arg2 = (Dali::Property::Index)jarg2;
66091
66092   Dali::Property::Index arg3 = 0 ;
66093   arg3 = (Dali::Property::Index)jarg3;
66094
66095   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
66096
66097   {
66098     try {
66099       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
66100     } catch (std::out_of_range& e) {
66101       {
66102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66103       };
66104     } catch (std::exception& e) {
66105       {
66106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66107       };
66108     } catch (...) {
66109       {
66110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66111       };
66112     }
66113   }
66114
66115
66116 }
66117
66118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
66119   void * jresult ;
66120   Dali::Toolkit::Control *arg1 = 0 ;
66121   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
66122
66123   arg1 = (Dali::Toolkit::Control *)jarg1;
66124   if (!arg1) {
66125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66126     return 0;
66127   }
66128   {
66129     try {
66130       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
66131     } catch (std::out_of_range& e) {
66132       {
66133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66134       };
66135     } catch (std::exception& e) {
66136       {
66137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66138       };
66139     } catch (Dali::DaliException e) {
66140       {
66141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66142       };
66143     } catch (...) {
66144       {
66145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66146       };
66147     }
66148   }
66149
66150   jresult = (void *)result;
66151   return jresult;
66152 }
66153
66154
66155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
66156   unsigned int jresult ;
66157   Dali::Toolkit::Control *arg1 = 0 ;
66158   bool result;
66159
66160   arg1 = (Dali::Toolkit::Control *)jarg1;
66161   if (!arg1) {
66162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
66163     return 0;
66164   }
66165   {
66166     try {
66167       result = (bool)arg1->IsResourceReady();
66168     } catch (std::out_of_range& e) {
66169       {
66170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66171       };
66172     } catch (std::exception& e) {
66173       {
66174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66175       };
66176     } catch (Dali::DaliException e) {
66177       {
66178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66179       };
66180     } catch (...) {
66181       {
66182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66183       };
66184     }
66185   }
66186
66187   jresult = result;
66188   return jresult;
66189 }
66190
66191
66192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
66193   void * jresult ;
66194   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
66195
66196   {
66197     try {
66198       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
66199     } catch (std::out_of_range& e) {
66200       {
66201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66202       };
66203     } catch (std::exception& e) {
66204       {
66205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66206       };
66207     } catch (Dali::DaliException e) {
66208       {
66209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66210       };
66211     } catch (...) {
66212       {
66213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66214       };
66215     }
66216   }
66217
66218   jresult = (void *)result;
66219   return jresult;
66220 }
66221
66222
66223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
66224   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
66225
66226   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
66227   {
66228     try {
66229       delete arg1;
66230     } catch (std::out_of_range& e) {
66231       {
66232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66233       };
66234     } catch (std::exception& e) {
66235       {
66236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66237       };
66238     } catch (Dali::DaliException e) {
66239       {
66240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66241       };
66242     } catch (...) {
66243       {
66244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66245       };
66246     }
66247   }
66248
66249 }
66250
66251
66252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
66253   void * jresult ;
66254   Dali::Toolkit::KeyInputFocusManager result;
66255
66256   {
66257     try {
66258       result = Dali::Toolkit::KeyInputFocusManager::Get();
66259     } catch (std::out_of_range& e) {
66260       {
66261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66262       };
66263     } catch (std::exception& e) {
66264       {
66265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66266       };
66267     } catch (Dali::DaliException e) {
66268       {
66269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66270       };
66271     } catch (...) {
66272       {
66273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66274       };
66275     }
66276   }
66277
66278   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
66279   return jresult;
66280 }
66281
66282
66283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
66284   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
66285   Dali::Toolkit::Control arg2 ;
66286   Dali::Toolkit::Control *argp2 ;
66287
66288   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
66289   argp2 = (Dali::Toolkit::Control *)jarg2;
66290   if (!argp2) {
66291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
66292     return ;
66293   }
66294   arg2 = *argp2;
66295   {
66296     try {
66297       (arg1)->SetFocus(arg2);
66298     } catch (std::out_of_range& e) {
66299       {
66300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66301       };
66302     } catch (std::exception& e) {
66303       {
66304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66305       };
66306     } catch (Dali::DaliException e) {
66307       {
66308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66309       };
66310     } catch (...) {
66311       {
66312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66313       };
66314     }
66315   }
66316
66317 }
66318
66319
66320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
66321   void * jresult ;
66322   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
66323   Dali::Toolkit::Control result;
66324
66325   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
66326   {
66327     try {
66328       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
66329     } catch (std::out_of_range& e) {
66330       {
66331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66332       };
66333     } catch (std::exception& e) {
66334       {
66335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66336       };
66337     } catch (Dali::DaliException e) {
66338       {
66339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66340       };
66341     } catch (...) {
66342       {
66343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66344       };
66345     }
66346   }
66347
66348   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
66349   return jresult;
66350 }
66351
66352
66353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
66354   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
66355   Dali::Toolkit::Control arg2 ;
66356   Dali::Toolkit::Control *argp2 ;
66357
66358   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
66359   argp2 = (Dali::Toolkit::Control *)jarg2;
66360   if (!argp2) {
66361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
66362     return ;
66363   }
66364   arg2 = *argp2;
66365   {
66366     try {
66367       (arg1)->RemoveFocus(arg2);
66368     } catch (std::out_of_range& e) {
66369       {
66370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66371       };
66372     } catch (std::exception& e) {
66373       {
66374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66375       };
66376     } catch (Dali::DaliException e) {
66377       {
66378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66379       };
66380     } catch (...) {
66381       {
66382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66383       };
66384     }
66385   }
66386
66387 }
66388
66389
66390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
66391   void * jresult ;
66392   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
66393   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
66394
66395   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
66396   {
66397     try {
66398       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
66399     } catch (std::out_of_range& e) {
66400       {
66401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66402       };
66403     } catch (std::exception& e) {
66404       {
66405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66406       };
66407     } catch (Dali::DaliException e) {
66408       {
66409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66410       };
66411     } catch (...) {
66412       {
66413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66414       };
66415     }
66416   }
66417
66418   jresult = (void *)result;
66419   return jresult;
66420 }
66421
66422
66423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
66424   void * jresult ;
66425   Dali::Toolkit::Alignment::Padding *result = 0 ;
66426
66427   {
66428     try {
66429       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
66430     } catch (std::out_of_range& e) {
66431       {
66432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66433       };
66434     } catch (std::exception& e) {
66435       {
66436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66437       };
66438     } catch (Dali::DaliException e) {
66439       {
66440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66441       };
66442     } catch (...) {
66443       {
66444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66445       };
66446     }
66447   }
66448
66449   jresult = (void *)result;
66450   return jresult;
66451 }
66452
66453
66454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
66455   void * jresult ;
66456   float arg1 ;
66457   float arg2 ;
66458   float arg3 ;
66459   float arg4 ;
66460   Dali::Toolkit::Alignment::Padding *result = 0 ;
66461
66462   arg1 = (float)jarg1;
66463   arg2 = (float)jarg2;
66464   arg3 = (float)jarg3;
66465   arg4 = (float)jarg4;
66466   {
66467     try {
66468       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
66469     } catch (std::out_of_range& e) {
66470       {
66471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66472       };
66473     } catch (std::exception& e) {
66474       {
66475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66476       };
66477     } catch (Dali::DaliException e) {
66478       {
66479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66480       };
66481     } catch (...) {
66482       {
66483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66484       };
66485     }
66486   }
66487
66488   jresult = (void *)result;
66489   return jresult;
66490 }
66491
66492
66493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
66494   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
66495   float arg2 ;
66496
66497   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
66498   arg2 = (float)jarg2;
66499   if (arg1) (arg1)->left = arg2;
66500 }
66501
66502
66503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
66504   float jresult ;
66505   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
66506   float result;
66507
66508   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
66509   result = (float) ((arg1)->left);
66510   jresult = result;
66511   return jresult;
66512 }
66513
66514
66515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
66516   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
66517   float arg2 ;
66518
66519   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
66520   arg2 = (float)jarg2;
66521   if (arg1) (arg1)->right = arg2;
66522 }
66523
66524
66525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
66526   float jresult ;
66527   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
66528   float result;
66529
66530   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
66531   result = (float) ((arg1)->right);
66532   jresult = result;
66533   return jresult;
66534 }
66535
66536
66537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
66538   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
66539   float arg2 ;
66540
66541   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
66542   arg2 = (float)jarg2;
66543   if (arg1) (arg1)->top = arg2;
66544 }
66545
66546
66547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
66548   float jresult ;
66549   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
66550   float result;
66551
66552   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
66553   result = (float) ((arg1)->top);
66554   jresult = result;
66555   return jresult;
66556 }
66557
66558
66559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
66560   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
66561   float arg2 ;
66562
66563   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
66564   arg2 = (float)jarg2;
66565   if (arg1) (arg1)->bottom = arg2;
66566 }
66567
66568
66569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
66570   float jresult ;
66571   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
66572   float result;
66573
66574   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
66575   result = (float) ((arg1)->bottom);
66576   jresult = result;
66577   return jresult;
66578 }
66579
66580
66581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
66582   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
66583
66584   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
66585   {
66586     try {
66587       delete arg1;
66588     } catch (std::out_of_range& e) {
66589       {
66590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66591       };
66592     } catch (std::exception& e) {
66593       {
66594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66595       };
66596     } catch (Dali::DaliException e) {
66597       {
66598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66599       };
66600     } catch (...) {
66601       {
66602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66603       };
66604     }
66605   }
66606
66607 }
66608
66609
66610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
66611   void * jresult ;
66612   Dali::Toolkit::Alignment *result = 0 ;
66613
66614   {
66615     try {
66616       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
66617     } catch (std::out_of_range& e) {
66618       {
66619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66620       };
66621     } catch (std::exception& e) {
66622       {
66623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66624       };
66625     } catch (Dali::DaliException e) {
66626       {
66627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66628       };
66629     } catch (...) {
66630       {
66631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66632       };
66633     }
66634   }
66635
66636   jresult = (void *)result;
66637   return jresult;
66638 }
66639
66640
66641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
66642   void * jresult ;
66643   Dali::Toolkit::Alignment::Type arg1 ;
66644   Dali::Toolkit::Alignment::Type arg2 ;
66645   Dali::Toolkit::Alignment result;
66646
66647   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
66648   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
66649   {
66650     try {
66651       result = Dali::Toolkit::Alignment::New(arg1,arg2);
66652     } catch (std::out_of_range& e) {
66653       {
66654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66655       };
66656     } catch (std::exception& e) {
66657       {
66658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66659       };
66660     } catch (Dali::DaliException e) {
66661       {
66662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66663       };
66664     } catch (...) {
66665       {
66666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66667       };
66668     }
66669   }
66670
66671   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
66672   return jresult;
66673 }
66674
66675
66676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
66677   void * jresult ;
66678   Dali::Toolkit::Alignment::Type arg1 ;
66679   Dali::Toolkit::Alignment result;
66680
66681   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
66682   {
66683     try {
66684       result = Dali::Toolkit::Alignment::New(arg1);
66685     } catch (std::out_of_range& e) {
66686       {
66687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66688       };
66689     } catch (std::exception& e) {
66690       {
66691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66692       };
66693     } catch (Dali::DaliException e) {
66694       {
66695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66696       };
66697     } catch (...) {
66698       {
66699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66700       };
66701     }
66702   }
66703
66704   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
66705   return jresult;
66706 }
66707
66708
66709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
66710   void * jresult ;
66711   Dali::Toolkit::Alignment result;
66712
66713   {
66714     try {
66715       result = Dali::Toolkit::Alignment::New();
66716     } catch (std::out_of_range& e) {
66717       {
66718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66719       };
66720     } catch (std::exception& e) {
66721       {
66722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66723       };
66724     } catch (Dali::DaliException e) {
66725       {
66726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66727       };
66728     } catch (...) {
66729       {
66730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66731       };
66732     }
66733   }
66734
66735   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
66736   return jresult;
66737 }
66738
66739
66740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
66741   void * jresult ;
66742   Dali::Toolkit::Alignment *arg1 = 0 ;
66743   Dali::Toolkit::Alignment *result = 0 ;
66744
66745   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66746   if (!arg1) {
66747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
66748     return 0;
66749   }
66750   {
66751     try {
66752       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
66753     } catch (std::out_of_range& e) {
66754       {
66755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66756       };
66757     } catch (std::exception& e) {
66758       {
66759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66760       };
66761     } catch (Dali::DaliException e) {
66762       {
66763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66764       };
66765     } catch (...) {
66766       {
66767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66768       };
66769     }
66770   }
66771
66772   jresult = (void *)result;
66773   return jresult;
66774 }
66775
66776
66777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
66778   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66779
66780   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66781   {
66782     try {
66783       delete arg1;
66784     } catch (std::out_of_range& e) {
66785       {
66786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66787       };
66788     } catch (std::exception& e) {
66789       {
66790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66791       };
66792     } catch (Dali::DaliException e) {
66793       {
66794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66795       };
66796     } catch (...) {
66797       {
66798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66799       };
66800     }
66801   }
66802
66803 }
66804
66805
66806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
66807   void * jresult ;
66808   Dali::BaseHandle arg1 ;
66809   Dali::BaseHandle *argp1 ;
66810   Dali::Toolkit::Alignment result;
66811
66812   argp1 = (Dali::BaseHandle *)jarg1;
66813   if (!argp1) {
66814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66815     return 0;
66816   }
66817   arg1 = *argp1;
66818   {
66819     try {
66820       result = Dali::Toolkit::Alignment::DownCast(arg1);
66821     } catch (std::out_of_range& e) {
66822       {
66823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66824       };
66825     } catch (std::exception& e) {
66826       {
66827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66828       };
66829     } catch (Dali::DaliException e) {
66830       {
66831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66832       };
66833     } catch (...) {
66834       {
66835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66836       };
66837     }
66838   }
66839
66840   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
66841   return jresult;
66842 }
66843
66844
66845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
66846   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66847   Dali::Toolkit::Alignment::Type arg2 ;
66848
66849   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66850   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
66851   {
66852     try {
66853       (arg1)->SetAlignmentType(arg2);
66854     } catch (std::out_of_range& e) {
66855       {
66856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66857       };
66858     } catch (std::exception& e) {
66859       {
66860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66861       };
66862     } catch (Dali::DaliException e) {
66863       {
66864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66865       };
66866     } catch (...) {
66867       {
66868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66869       };
66870     }
66871   }
66872
66873 }
66874
66875
66876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
66877   int jresult ;
66878   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66879   Dali::Toolkit::Alignment::Type result;
66880
66881   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66882   {
66883     try {
66884       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
66885     } catch (std::out_of_range& e) {
66886       {
66887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66888       };
66889     } catch (std::exception& e) {
66890       {
66891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66892       };
66893     } catch (Dali::DaliException e) {
66894       {
66895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66896       };
66897     } catch (...) {
66898       {
66899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66900       };
66901     }
66902   }
66903
66904   jresult = (int)result;
66905   return jresult;
66906 }
66907
66908
66909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
66910   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66911   Dali::Toolkit::Alignment::Scaling arg2 ;
66912
66913   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66914   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
66915   {
66916     try {
66917       (arg1)->SetScaling(arg2);
66918     } catch (std::out_of_range& e) {
66919       {
66920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66921       };
66922     } catch (std::exception& e) {
66923       {
66924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66925       };
66926     } catch (Dali::DaliException e) {
66927       {
66928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66929       };
66930     } catch (...) {
66931       {
66932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66933       };
66934     }
66935   }
66936
66937 }
66938
66939
66940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
66941   int jresult ;
66942   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66943   Dali::Toolkit::Alignment::Scaling result;
66944
66945   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66946   {
66947     try {
66948       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
66949     } catch (std::out_of_range& e) {
66950       {
66951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66952       };
66953     } catch (std::exception& e) {
66954       {
66955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66956       };
66957     } catch (Dali::DaliException e) {
66958       {
66959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66960       };
66961     } catch (...) {
66962       {
66963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66964       };
66965     }
66966   }
66967
66968   jresult = (int)result;
66969   return jresult;
66970 }
66971
66972
66973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
66974   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
66975   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
66976
66977   arg1 = (Dali::Toolkit::Alignment *)jarg1;
66978   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
66979   if (!arg2) {
66980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
66981     return ;
66982   }
66983   {
66984     try {
66985       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
66986     } catch (std::out_of_range& e) {
66987       {
66988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66989       };
66990     } catch (std::exception& e) {
66991       {
66992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66993       };
66994     } catch (Dali::DaliException e) {
66995       {
66996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66997       };
66998     } catch (...) {
66999       {
67000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67001       };
67002     }
67003   }
67004
67005 }
67006
67007
67008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
67009   void * jresult ;
67010   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
67011   Dali::Toolkit::Alignment::Padding *result = 0 ;
67012
67013   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67014   {
67015     try {
67016       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
67017     } catch (std::out_of_range& e) {
67018       {
67019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67020       };
67021     } catch (std::exception& e) {
67022       {
67023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67024       };
67025     } catch (Dali::DaliException e) {
67026       {
67027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67028       };
67029     } catch (...) {
67030       {
67031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67032       };
67033     }
67034   }
67035
67036   jresult = (void *)result;
67037   return jresult;
67038 }
67039
67040
67041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
67042   void * jresult ;
67043   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
67044   Dali::Toolkit::Alignment *arg2 = 0 ;
67045   Dali::Toolkit::Alignment *result = 0 ;
67046
67047   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67048   arg2 = (Dali::Toolkit::Alignment *)jarg2;
67049   if (!arg2) {
67050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
67051     return 0;
67052   }
67053   {
67054     try {
67055       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
67056     } catch (std::out_of_range& e) {
67057       {
67058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67059       };
67060     } catch (std::exception& e) {
67061       {
67062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67063       };
67064     } catch (Dali::DaliException e) {
67065       {
67066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67067       };
67068     } catch (...) {
67069       {
67070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67071       };
67072     }
67073   }
67074
67075   jresult = (void *)result;
67076   return jresult;
67077 }
67078
67079
67080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
67081   int jresult ;
67082   int result;
67083
67084   result = (int)Dali::Toolkit::Button::Property::DISABLED;
67085   jresult = (int)result;
67086   return jresult;
67087 }
67088
67089
67090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
67091   int jresult ;
67092   int result;
67093
67094   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
67095   jresult = (int)result;
67096   return jresult;
67097 }
67098
67099
67100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
67101   int jresult ;
67102   int result;
67103
67104   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
67105   jresult = (int)result;
67106   return jresult;
67107 }
67108
67109
67110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
67111   int jresult ;
67112   int result;
67113
67114   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
67115   jresult = (int)result;
67116   return jresult;
67117 }
67118
67119
67120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
67121   int jresult ;
67122   int result;
67123
67124   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
67125   jresult = (int)result;
67126   return jresult;
67127 }
67128
67129
67130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
67131   int jresult ;
67132   int result;
67133
67134   result = (int)Dali::Toolkit::Button::Property::SELECTED;
67135   jresult = (int)result;
67136   return jresult;
67137 }
67138
67139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
67140   int jresult ;
67141   int result;
67142
67143   result = (int)Dali::Toolkit::Button::Property::LABEL;
67144   jresult = (int)result;
67145   return jresult;
67146 }
67147
67148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
67149   void * jresult ;
67150   Dali::Toolkit::Button::Property *result = 0 ;
67151
67152   {
67153     try {
67154       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
67155     } catch (std::out_of_range& e) {
67156       {
67157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67158       };
67159     } catch (std::exception& e) {
67160       {
67161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67162       };
67163     } catch (Dali::DaliException e) {
67164       {
67165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67166       };
67167     } catch (...) {
67168       {
67169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67170       };
67171     }
67172   }
67173
67174   jresult = (void *)result;
67175   return jresult;
67176 }
67177
67178
67179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
67180   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
67181
67182   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
67183   {
67184     try {
67185       delete arg1;
67186     } catch (std::out_of_range& e) {
67187       {
67188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67189       };
67190     } catch (std::exception& e) {
67191       {
67192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67193       };
67194     } catch (Dali::DaliException e) {
67195       {
67196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67197       };
67198     } catch (...) {
67199       {
67200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67201       };
67202     }
67203   }
67204
67205 }
67206
67207
67208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
67209   void * jresult ;
67210   Dali::Toolkit::Button *result = 0 ;
67211
67212   {
67213     try {
67214       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
67215     } catch (std::out_of_range& e) {
67216       {
67217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67218       };
67219     } catch (std::exception& e) {
67220       {
67221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67222       };
67223     } catch (Dali::DaliException e) {
67224       {
67225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67226       };
67227     } catch (...) {
67228       {
67229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67230       };
67231     }
67232   }
67233
67234   jresult = (void *)result;
67235   return jresult;
67236 }
67237
67238
67239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
67240   void * jresult ;
67241   Dali::Toolkit::Button *arg1 = 0 ;
67242   Dali::Toolkit::Button *result = 0 ;
67243
67244   arg1 = (Dali::Toolkit::Button *)jarg1;
67245   if (!arg1) {
67246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
67247     return 0;
67248   }
67249   {
67250     try {
67251       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
67252     } catch (std::out_of_range& e) {
67253       {
67254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67255       };
67256     } catch (std::exception& e) {
67257       {
67258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67259       };
67260     } catch (Dali::DaliException e) {
67261       {
67262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67263       };
67264     } catch (...) {
67265       {
67266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67267       };
67268     }
67269   }
67270
67271   jresult = (void *)result;
67272   return jresult;
67273 }
67274
67275
67276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
67277   void * jresult ;
67278   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67279   Dali::Toolkit::Button *arg2 = 0 ;
67280   Dali::Toolkit::Button *result = 0 ;
67281
67282   arg1 = (Dali::Toolkit::Button *)jarg1;
67283   arg2 = (Dali::Toolkit::Button *)jarg2;
67284   if (!arg2) {
67285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
67286     return 0;
67287   }
67288   {
67289     try {
67290       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
67291     } catch (std::out_of_range& e) {
67292       {
67293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67294       };
67295     } catch (std::exception& e) {
67296       {
67297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67298       };
67299     } catch (Dali::DaliException e) {
67300       {
67301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67302       };
67303     } catch (...) {
67304       {
67305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67306       };
67307     }
67308   }
67309
67310   jresult = (void *)result;
67311   return jresult;
67312 }
67313
67314
67315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
67316   void * jresult ;
67317   Dali::BaseHandle arg1 ;
67318   Dali::BaseHandle *argp1 ;
67319   Dali::Toolkit::Button result;
67320
67321   argp1 = (Dali::BaseHandle *)jarg1;
67322   if (!argp1) {
67323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67324     return 0;
67325   }
67326   arg1 = *argp1;
67327   {
67328     try {
67329       result = Dali::Toolkit::Button::DownCast(arg1);
67330     } catch (std::out_of_range& e) {
67331       {
67332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67333       };
67334     } catch (std::exception& e) {
67335       {
67336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67337       };
67338     } catch (Dali::DaliException e) {
67339       {
67340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67341       };
67342     } catch (...) {
67343       {
67344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67345       };
67346     }
67347   }
67348
67349   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
67350   return jresult;
67351 }
67352
67353
67354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
67355   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67356
67357   arg1 = (Dali::Toolkit::Button *)jarg1;
67358   {
67359     try {
67360       delete arg1;
67361     } catch (std::out_of_range& e) {
67362       {
67363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67364       };
67365     } catch (std::exception& e) {
67366       {
67367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67368       };
67369     } catch (Dali::DaliException e) {
67370       {
67371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67372       };
67373     } catch (...) {
67374       {
67375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67376       };
67377     }
67378   }
67379
67380 }
67381
67382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
67383   void * jresult ;
67384   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67385   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
67386
67387   arg1 = (Dali::Toolkit::Button *)jarg1;
67388   {
67389     try {
67390       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
67391     } catch (std::out_of_range& e) {
67392       {
67393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67394       };
67395     } catch (std::exception& e) {
67396       {
67397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67398       };
67399     } catch (Dali::DaliException e) {
67400       {
67401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67402       };
67403     } catch (...) {
67404       {
67405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67406       };
67407     }
67408   }
67409
67410   jresult = (void *)result;
67411   return jresult;
67412 }
67413
67414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
67415   void * jresult ;
67416   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67417   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
67418
67419   arg1 = (Dali::Toolkit::Button *)jarg1;
67420   {
67421     try {
67422       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
67423     } catch (std::out_of_range& e) {
67424       {
67425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67426       };
67427     } catch (std::exception& e) {
67428       {
67429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67430       };
67431     } catch (Dali::DaliException e) {
67432       {
67433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67434       };
67435     } catch (...) {
67436       {
67437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67438       };
67439     }
67440   }
67441
67442   jresult = (void *)result;
67443   return jresult;
67444 }
67445
67446
67447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
67448   void * jresult ;
67449   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67450   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
67451
67452   arg1 = (Dali::Toolkit::Button *)jarg1;
67453   {
67454     try {
67455       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
67456     } catch (std::out_of_range& e) {
67457       {
67458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67459       };
67460     } catch (std::exception& e) {
67461       {
67462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67463       };
67464     } catch (Dali::DaliException e) {
67465       {
67466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67467       };
67468     } catch (...) {
67469       {
67470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67471       };
67472     }
67473   }
67474
67475   jresult = (void *)result;
67476   return jresult;
67477 }
67478
67479
67480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
67481   void * jresult ;
67482   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67483   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
67484
67485   arg1 = (Dali::Toolkit::Button *)jarg1;
67486   {
67487     try {
67488       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
67489     } catch (std::out_of_range& e) {
67490       {
67491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67492       };
67493     } catch (std::exception& e) {
67494       {
67495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67496       };
67497     } catch (Dali::DaliException e) {
67498       {
67499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67500       };
67501     } catch (...) {
67502       {
67503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67504       };
67505     }
67506   }
67507
67508   jresult = (void *)result;
67509   return jresult;
67510 }
67511
67512
67513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
67514   void * jresult ;
67515   Dali::Toolkit::CheckBoxButton *result = 0 ;
67516
67517   {
67518     try {
67519       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
67520     } catch (std::out_of_range& e) {
67521       {
67522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67523       };
67524     } catch (std::exception& e) {
67525       {
67526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67527       };
67528     } catch (Dali::DaliException e) {
67529       {
67530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67531       };
67532     } catch (...) {
67533       {
67534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67535       };
67536     }
67537   }
67538
67539   jresult = (void *)result;
67540   return jresult;
67541 }
67542
67543
67544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
67545   void * jresult ;
67546   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
67547   Dali::Toolkit::CheckBoxButton *result = 0 ;
67548
67549   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
67550   if (!arg1) {
67551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
67552     return 0;
67553   }
67554   {
67555     try {
67556       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
67557     } catch (std::out_of_range& e) {
67558       {
67559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67560       };
67561     } catch (std::exception& e) {
67562       {
67563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67564       };
67565     } catch (Dali::DaliException e) {
67566       {
67567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67568       };
67569     } catch (...) {
67570       {
67571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67572       };
67573     }
67574   }
67575
67576   jresult = (void *)result;
67577   return jresult;
67578 }
67579
67580
67581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
67582   void * jresult ;
67583   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
67584   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
67585   Dali::Toolkit::CheckBoxButton *result = 0 ;
67586
67587   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
67588   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
67589   if (!arg2) {
67590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
67591     return 0;
67592   }
67593   {
67594     try {
67595       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
67596     } catch (std::out_of_range& e) {
67597       {
67598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67599       };
67600     } catch (std::exception& e) {
67601       {
67602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67603       };
67604     } catch (Dali::DaliException e) {
67605       {
67606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67607       };
67608     } catch (...) {
67609       {
67610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67611       };
67612     }
67613   }
67614
67615   jresult = (void *)result;
67616   return jresult;
67617 }
67618
67619
67620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
67621   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
67622
67623   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
67624   {
67625     try {
67626       delete arg1;
67627     } catch (std::out_of_range& e) {
67628       {
67629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67630       };
67631     } catch (std::exception& e) {
67632       {
67633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67634       };
67635     } catch (Dali::DaliException e) {
67636       {
67637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67638       };
67639     } catch (...) {
67640       {
67641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67642       };
67643     }
67644   }
67645
67646 }
67647
67648
67649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
67650   void * jresult ;
67651   Dali::Toolkit::CheckBoxButton result;
67652
67653   {
67654     try {
67655       result = Dali::Toolkit::CheckBoxButton::New();
67656     } catch (std::out_of_range& e) {
67657       {
67658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67659       };
67660     } catch (std::exception& e) {
67661       {
67662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67663       };
67664     } catch (Dali::DaliException e) {
67665       {
67666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67667       };
67668     } catch (...) {
67669       {
67670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67671       };
67672     }
67673   }
67674
67675   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
67676   return jresult;
67677 }
67678
67679
67680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
67681   void * jresult ;
67682   Dali::BaseHandle arg1 ;
67683   Dali::BaseHandle *argp1 ;
67684   Dali::Toolkit::CheckBoxButton result;
67685
67686   argp1 = (Dali::BaseHandle *)jarg1;
67687   if (!argp1) {
67688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67689     return 0;
67690   }
67691   arg1 = *argp1;
67692   {
67693     try {
67694       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
67695     } catch (std::out_of_range& e) {
67696       {
67697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67698       };
67699     } catch (std::exception& e) {
67700       {
67701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67702       };
67703     } catch (Dali::DaliException e) {
67704       {
67705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67706       };
67707     } catch (...) {
67708       {
67709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67710       };
67711     }
67712   }
67713
67714   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
67715   return jresult;
67716 }
67717
67718
67719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
67720   int jresult ;
67721   int result;
67722
67723   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
67724   jresult = (int)result;
67725   return jresult;
67726 }
67727
67728
67729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
67730   int jresult ;
67731   int result;
67732
67733   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
67734   jresult = (int)result;
67735   return jresult;
67736 }
67737
67738
67739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
67740   int jresult ;
67741   int result;
67742
67743   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
67744   jresult = (int)result;
67745   return jresult;
67746 }
67747
67748
67749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
67750   int jresult ;
67751   int result;
67752
67753   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
67754   jresult = (int)result;
67755   return jresult;
67756 }
67757
67758
67759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
67760   int jresult ;
67761   int result;
67762
67763   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
67764   jresult = (int)result;
67765   return jresult;
67766 }
67767
67768
67769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
67770   void * jresult ;
67771   Dali::Toolkit::PushButton::Property *result = 0 ;
67772
67773   {
67774     try {
67775       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
67776     } catch (std::out_of_range& e) {
67777       {
67778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67779       };
67780     } catch (std::exception& e) {
67781       {
67782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67783       };
67784     } catch (Dali::DaliException e) {
67785       {
67786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67787       };
67788     } catch (...) {
67789       {
67790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67791       };
67792     }
67793   }
67794
67795   jresult = (void *)result;
67796   return jresult;
67797 }
67798
67799
67800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
67801   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
67802
67803   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
67804   {
67805     try {
67806       delete arg1;
67807     } catch (std::out_of_range& e) {
67808       {
67809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67810       };
67811     } catch (std::exception& e) {
67812       {
67813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67814       };
67815     } catch (Dali::DaliException e) {
67816       {
67817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67818       };
67819     } catch (...) {
67820       {
67821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67822       };
67823     }
67824   }
67825
67826 }
67827
67828
67829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
67830   void * jresult ;
67831   Dali::Toolkit::PushButton *result = 0 ;
67832
67833   {
67834     try {
67835       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
67836     } catch (std::out_of_range& e) {
67837       {
67838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67839       };
67840     } catch (std::exception& e) {
67841       {
67842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67843       };
67844     } catch (Dali::DaliException e) {
67845       {
67846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67847       };
67848     } catch (...) {
67849       {
67850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67851       };
67852     }
67853   }
67854
67855   jresult = (void *)result;
67856   return jresult;
67857 }
67858
67859
67860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
67861   void * jresult ;
67862   Dali::Toolkit::PushButton *arg1 = 0 ;
67863   Dali::Toolkit::PushButton *result = 0 ;
67864
67865   arg1 = (Dali::Toolkit::PushButton *)jarg1;
67866   if (!arg1) {
67867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
67868     return 0;
67869   }
67870   {
67871     try {
67872       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
67873     } catch (std::out_of_range& e) {
67874       {
67875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67876       };
67877     } catch (std::exception& e) {
67878       {
67879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67880       };
67881     } catch (Dali::DaliException e) {
67882       {
67883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67884       };
67885     } catch (...) {
67886       {
67887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67888       };
67889     }
67890   }
67891
67892   jresult = (void *)result;
67893   return jresult;
67894 }
67895
67896
67897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
67898   void * jresult ;
67899   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
67900   Dali::Toolkit::PushButton *arg2 = 0 ;
67901   Dali::Toolkit::PushButton *result = 0 ;
67902
67903   arg1 = (Dali::Toolkit::PushButton *)jarg1;
67904   arg2 = (Dali::Toolkit::PushButton *)jarg2;
67905   if (!arg2) {
67906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
67907     return 0;
67908   }
67909   {
67910     try {
67911       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
67912     } catch (std::out_of_range& e) {
67913       {
67914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67915       };
67916     } catch (std::exception& e) {
67917       {
67918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67919       };
67920     } catch (Dali::DaliException e) {
67921       {
67922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67923       };
67924     } catch (...) {
67925       {
67926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67927       };
67928     }
67929   }
67930
67931   jresult = (void *)result;
67932   return jresult;
67933 }
67934
67935
67936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
67937   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
67938
67939   arg1 = (Dali::Toolkit::PushButton *)jarg1;
67940   {
67941     try {
67942       delete arg1;
67943     } catch (std::out_of_range& e) {
67944       {
67945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67946       };
67947     } catch (std::exception& e) {
67948       {
67949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67950       };
67951     } catch (Dali::DaliException e) {
67952       {
67953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67954       };
67955     } catch (...) {
67956       {
67957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67958       };
67959     }
67960   }
67961
67962 }
67963
67964
67965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
67966   void * jresult ;
67967   Dali::Toolkit::PushButton result;
67968
67969   {
67970     try {
67971       result = Dali::Toolkit::PushButton::New();
67972     } catch (std::out_of_range& e) {
67973       {
67974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67975       };
67976     } catch (std::exception& e) {
67977       {
67978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67979       };
67980     } catch (Dali::DaliException e) {
67981       {
67982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67983       };
67984     } catch (...) {
67985       {
67986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67987       };
67988     }
67989   }
67990
67991   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
67992   return jresult;
67993 }
67994
67995
67996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
67997   void * jresult ;
67998   Dali::BaseHandle arg1 ;
67999   Dali::BaseHandle *argp1 ;
68000   Dali::Toolkit::PushButton result;
68001
68002   argp1 = (Dali::BaseHandle *)jarg1;
68003   if (!argp1) {
68004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68005     return 0;
68006   }
68007   arg1 = *argp1;
68008   {
68009     try {
68010       result = Dali::Toolkit::PushButton::DownCast(arg1);
68011     } catch (std::out_of_range& e) {
68012       {
68013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68014       };
68015     } catch (std::exception& e) {
68016       {
68017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68018       };
68019     } catch (Dali::DaliException e) {
68020       {
68021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68022       };
68023     } catch (...) {
68024       {
68025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68026       };
68027     }
68028   }
68029
68030   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
68031   return jresult;
68032 }
68033
68034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
68035   void * jresult ;
68036   Dali::Toolkit::RadioButton *result = 0 ;
68037
68038   {
68039     try {
68040       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
68041     } catch (std::out_of_range& e) {
68042       {
68043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68044       };
68045     } catch (std::exception& e) {
68046       {
68047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68048       };
68049     } catch (Dali::DaliException e) {
68050       {
68051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68052       };
68053     } catch (...) {
68054       {
68055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68056       };
68057     }
68058   }
68059
68060   jresult = (void *)result;
68061   return jresult;
68062 }
68063
68064
68065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
68066   void * jresult ;
68067   Dali::Toolkit::RadioButton *arg1 = 0 ;
68068   Dali::Toolkit::RadioButton *result = 0 ;
68069
68070   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
68071   if (!arg1) {
68072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
68073     return 0;
68074   }
68075   {
68076     try {
68077       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
68078     } catch (std::out_of_range& e) {
68079       {
68080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68081       };
68082     } catch (std::exception& e) {
68083       {
68084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68085       };
68086     } catch (Dali::DaliException e) {
68087       {
68088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68089       };
68090     } catch (...) {
68091       {
68092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68093       };
68094     }
68095   }
68096
68097   jresult = (void *)result;
68098   return jresult;
68099 }
68100
68101
68102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
68103   void * jresult ;
68104   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
68105   Dali::Toolkit::RadioButton *arg2 = 0 ;
68106   Dali::Toolkit::RadioButton *result = 0 ;
68107
68108   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
68109   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
68110   if (!arg2) {
68111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
68112     return 0;
68113   }
68114   {
68115     try {
68116       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
68117     } catch (std::out_of_range& e) {
68118       {
68119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68120       };
68121     } catch (std::exception& e) {
68122       {
68123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68124       };
68125     } catch (Dali::DaliException e) {
68126       {
68127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68128       };
68129     } catch (...) {
68130       {
68131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68132       };
68133     }
68134   }
68135
68136   jresult = (void *)result;
68137   return jresult;
68138 }
68139
68140
68141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
68142   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
68143
68144   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
68145   {
68146     try {
68147       delete arg1;
68148     } catch (std::out_of_range& e) {
68149       {
68150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68151       };
68152     } catch (std::exception& e) {
68153       {
68154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68155       };
68156     } catch (Dali::DaliException e) {
68157       {
68158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68159       };
68160     } catch (...) {
68161       {
68162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68163       };
68164     }
68165   }
68166
68167 }
68168
68169
68170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
68171   void * jresult ;
68172   Dali::Toolkit::RadioButton result;
68173
68174   {
68175     try {
68176       result = Dali::Toolkit::RadioButton::New();
68177     } catch (std::out_of_range& e) {
68178       {
68179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68180       };
68181     } catch (std::exception& e) {
68182       {
68183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68184       };
68185     } catch (Dali::DaliException e) {
68186       {
68187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68188       };
68189     } catch (...) {
68190       {
68191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68192       };
68193     }
68194   }
68195
68196   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
68197   return jresult;
68198 }
68199
68200
68201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
68202   void * jresult ;
68203   std::string *arg1 = 0 ;
68204   Dali::Toolkit::RadioButton result;
68205
68206   if (!jarg1) {
68207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68208     return 0;
68209   }
68210   std::string arg1_str(jarg1);
68211   arg1 = &arg1_str;
68212   {
68213     try {
68214       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
68215     } catch (std::out_of_range& e) {
68216       {
68217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68218       };
68219     } catch (std::exception& e) {
68220       {
68221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68222       };
68223     } catch (Dali::DaliException e) {
68224       {
68225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68226       };
68227     } catch (...) {
68228       {
68229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68230       };
68231     }
68232   }
68233
68234   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
68235
68236   //argout typemap for const std::string&
68237
68238   return jresult;
68239 }
68240
68241
68242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
68243   void * jresult ;
68244   Dali::BaseHandle arg1 ;
68245   Dali::BaseHandle *argp1 ;
68246   Dali::Toolkit::RadioButton result;
68247
68248   argp1 = (Dali::BaseHandle *)jarg1;
68249   if (!argp1) {
68250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68251     return 0;
68252   }
68253   arg1 = *argp1;
68254   {
68255     try {
68256       result = Dali::Toolkit::RadioButton::DownCast(arg1);
68257     } catch (std::out_of_range& e) {
68258       {
68259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68260       };
68261     } catch (std::exception& e) {
68262       {
68263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68264       };
68265     } catch (Dali::DaliException e) {
68266       {
68267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68268       };
68269     } catch (...) {
68270       {
68271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68272       };
68273     }
68274   }
68275
68276   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
68277   return jresult;
68278 }
68279
68280
68281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
68282   int jresult ;
68283   int result;
68284
68285   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
68286   jresult = (int)result;
68287   return jresult;
68288 }
68289
68290
68291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
68292   int jresult ;
68293   int result;
68294
68295   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
68296   jresult = (int)result;
68297   return jresult;
68298 }
68299
68300
68301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
68302   int jresult ;
68303   int result;
68304
68305   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
68306   jresult = (int)result;
68307   return jresult;
68308 }
68309
68310
68311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
68312   int jresult ;
68313   int result;
68314
68315   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
68316   jresult = (int)result;
68317   return jresult;
68318 }
68319
68320
68321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
68322   int jresult ;
68323   int result;
68324
68325   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
68326   jresult = (int)result;
68327   return jresult;
68328 }
68329
68330
68331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
68332   int jresult ;
68333   int result;
68334
68335   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
68336   jresult = (int)result;
68337   return jresult;
68338 }
68339
68340
68341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
68342   void * jresult ;
68343   Dali::Toolkit::FlexContainer::Property *result = 0 ;
68344
68345   {
68346     try {
68347       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
68348     } catch (std::out_of_range& e) {
68349       {
68350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68351       };
68352     } catch (std::exception& e) {
68353       {
68354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68355       };
68356     } catch (Dali::DaliException e) {
68357       {
68358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68359       };
68360     } catch (...) {
68361       {
68362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68363       };
68364     }
68365   }
68366
68367   jresult = (void *)result;
68368   return jresult;
68369 }
68370
68371
68372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
68373   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
68374
68375   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
68376   {
68377     try {
68378       delete arg1;
68379     } catch (std::out_of_range& e) {
68380       {
68381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68382       };
68383     } catch (std::exception& e) {
68384       {
68385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68386       };
68387     } catch (Dali::DaliException e) {
68388       {
68389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68390       };
68391     } catch (...) {
68392       {
68393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68394       };
68395     }
68396   }
68397
68398 }
68399
68400
68401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
68402   int jresult ;
68403   int result;
68404
68405   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
68406   jresult = (int)result;
68407   return jresult;
68408 }
68409
68410
68411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
68412   int jresult ;
68413   int result;
68414
68415   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
68416   jresult = (int)result;
68417   return jresult;
68418 }
68419
68420
68421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
68422   int jresult ;
68423   int result;
68424
68425   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
68426   jresult = (int)result;
68427   return jresult;
68428 }
68429
68430
68431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
68432   void * jresult ;
68433   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
68434
68435   {
68436     try {
68437       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
68438     } catch (std::out_of_range& e) {
68439       {
68440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68441       };
68442     } catch (std::exception& e) {
68443       {
68444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68445       };
68446     } catch (Dali::DaliException e) {
68447       {
68448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68449       };
68450     } catch (...) {
68451       {
68452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68453       };
68454     }
68455   }
68456
68457   jresult = (void *)result;
68458   return jresult;
68459 }
68460
68461
68462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
68463   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
68464
68465   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
68466   {
68467     try {
68468       delete arg1;
68469     } catch (std::out_of_range& e) {
68470       {
68471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68472       };
68473     } catch (std::exception& e) {
68474       {
68475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68476       };
68477     } catch (Dali::DaliException e) {
68478       {
68479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68480       };
68481     } catch (...) {
68482       {
68483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68484       };
68485     }
68486   }
68487
68488 }
68489
68490
68491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
68492   void * jresult ;
68493   Dali::Toolkit::FlexContainer *result = 0 ;
68494
68495   {
68496     try {
68497       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
68498     } catch (std::out_of_range& e) {
68499       {
68500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68501       };
68502     } catch (std::exception& e) {
68503       {
68504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68505       };
68506     } catch (Dali::DaliException e) {
68507       {
68508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68509       };
68510     } catch (...) {
68511       {
68512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68513       };
68514     }
68515   }
68516
68517   jresult = (void *)result;
68518   return jresult;
68519 }
68520
68521
68522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
68523   void * jresult ;
68524   Dali::Toolkit::FlexContainer *arg1 = 0 ;
68525   Dali::Toolkit::FlexContainer *result = 0 ;
68526
68527   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
68528   if (!arg1) {
68529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
68530     return 0;
68531   }
68532   {
68533     try {
68534       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
68535     } catch (std::out_of_range& e) {
68536       {
68537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68538       };
68539     } catch (std::exception& e) {
68540       {
68541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68542       };
68543     } catch (Dali::DaliException e) {
68544       {
68545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68546       };
68547     } catch (...) {
68548       {
68549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68550       };
68551     }
68552   }
68553
68554   jresult = (void *)result;
68555   return jresult;
68556 }
68557
68558
68559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
68560   void * jresult ;
68561   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
68562   Dali::Toolkit::FlexContainer *arg2 = 0 ;
68563   Dali::Toolkit::FlexContainer *result = 0 ;
68564
68565   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
68566   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
68567   if (!arg2) {
68568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
68569     return 0;
68570   }
68571   {
68572     try {
68573       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
68574     } catch (std::out_of_range& e) {
68575       {
68576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68577       };
68578     } catch (std::exception& e) {
68579       {
68580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68581       };
68582     } catch (Dali::DaliException e) {
68583       {
68584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68585       };
68586     } catch (...) {
68587       {
68588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68589       };
68590     }
68591   }
68592
68593   jresult = (void *)result;
68594   return jresult;
68595 }
68596
68597
68598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
68599   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
68600
68601   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
68602   {
68603     try {
68604       delete arg1;
68605     } catch (std::out_of_range& e) {
68606       {
68607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68608       };
68609     } catch (std::exception& e) {
68610       {
68611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68612       };
68613     } catch (Dali::DaliException e) {
68614       {
68615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68616       };
68617     } catch (...) {
68618       {
68619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68620       };
68621     }
68622   }
68623
68624 }
68625
68626
68627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
68628   void * jresult ;
68629   Dali::Toolkit::FlexContainer result;
68630
68631   {
68632     try {
68633       result = Dali::Toolkit::FlexContainer::New();
68634     } catch (std::out_of_range& e) {
68635       {
68636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68637       };
68638     } catch (std::exception& e) {
68639       {
68640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68641       };
68642     } catch (Dali::DaliException e) {
68643       {
68644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68645       };
68646     } catch (...) {
68647       {
68648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68649       };
68650     }
68651   }
68652
68653   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
68654   return jresult;
68655 }
68656
68657
68658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
68659   void * jresult ;
68660   Dali::BaseHandle arg1 ;
68661   Dali::BaseHandle *argp1 ;
68662   Dali::Toolkit::FlexContainer result;
68663
68664   argp1 = (Dali::BaseHandle *)jarg1;
68665   if (!argp1) {
68666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68667     return 0;
68668   }
68669   arg1 = *argp1;
68670   {
68671     try {
68672       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
68673     } catch (std::out_of_range& e) {
68674       {
68675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68676       };
68677     } catch (std::exception& e) {
68678       {
68679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68680       };
68681     } catch (Dali::DaliException e) {
68682       {
68683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68684       };
68685     } catch (...) {
68686       {
68687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68688       };
68689     }
68690   }
68691
68692   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
68693   return jresult;
68694 }
68695
68696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
68697   int jresult ;
68698   int result;
68699
68700   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
68701   jresult = (int)result;
68702   return jresult;
68703 }
68704
68705
68706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
68707   int jresult ;
68708   int result;
68709
68710   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
68711   jresult = (int)result;
68712   return jresult;
68713 }
68714
68715
68716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
68717   int jresult ;
68718   int result;
68719
68720   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
68721   jresult = (int)result;
68722   return jresult;
68723 }
68724
68725
68726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
68727   void * jresult ;
68728   Dali::Toolkit::ImageView::Property *result = 0 ;
68729
68730   {
68731     try {
68732       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
68733     } catch (std::out_of_range& e) {
68734       {
68735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68736       };
68737     } catch (std::exception& e) {
68738       {
68739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68740       };
68741     } catch (Dali::DaliException e) {
68742       {
68743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68744       };
68745     } catch (...) {
68746       {
68747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68748       };
68749     }
68750   }
68751
68752   jresult = (void *)result;
68753   return jresult;
68754 }
68755
68756
68757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
68758   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
68759
68760   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
68761   {
68762     try {
68763       delete arg1;
68764     } catch (std::out_of_range& e) {
68765       {
68766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68767       };
68768     } catch (std::exception& e) {
68769       {
68770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68771       };
68772     } catch (Dali::DaliException e) {
68773       {
68774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68775       };
68776     } catch (...) {
68777       {
68778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68779       };
68780     }
68781   }
68782
68783 }
68784
68785
68786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
68787   void * jresult ;
68788   Dali::Toolkit::ImageView *result = 0 ;
68789
68790   {
68791     try {
68792       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
68793     } catch (std::out_of_range& e) {
68794       {
68795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68796       };
68797     } catch (std::exception& e) {
68798       {
68799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68800       };
68801     } catch (Dali::DaliException e) {
68802       {
68803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68804       };
68805     } catch (...) {
68806       {
68807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68808       };
68809     }
68810   }
68811
68812   jresult = (void *)result;
68813   return jresult;
68814 }
68815
68816
68817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
68818   void * jresult ;
68819   Dali::Toolkit::ImageView result;
68820
68821   {
68822     try {
68823       result = Dali::Toolkit::ImageView::New();
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 = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
68844   return jresult;
68845 }
68846
68847
68848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
68849   void * jresult ;
68850   std::string *arg1 = 0 ;
68851   Dali::Toolkit::ImageView result;
68852
68853   if (!jarg1) {
68854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68855     return 0;
68856   }
68857   std::string arg1_str(jarg1);
68858   arg1 = &arg1_str;
68859   {
68860     try {
68861       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
68862     } catch (std::out_of_range& e) {
68863       {
68864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68865       };
68866     } catch (std::exception& e) {
68867       {
68868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68869       };
68870     } catch (Dali::DaliException e) {
68871       {
68872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68873       };
68874     } catch (...) {
68875       {
68876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68877       };
68878     }
68879   }
68880
68881   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
68882
68883   //argout typemap for const std::string&
68884
68885   return jresult;
68886 }
68887
68888
68889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
68890   void * jresult ;
68891   std::string *arg1 = 0 ;
68892   Dali::ImageDimensions arg2 ;
68893   Dali::ImageDimensions *argp2 ;
68894   Dali::Toolkit::ImageView result;
68895
68896   if (!jarg1) {
68897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68898     return 0;
68899   }
68900   std::string arg1_str(jarg1);
68901   arg1 = &arg1_str;
68902   argp2 = (Dali::ImageDimensions *)jarg2;
68903   if (!argp2) {
68904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
68905     return 0;
68906   }
68907   arg2 = *argp2;
68908   {
68909     try {
68910       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
68911     } catch (std::out_of_range& e) {
68912       {
68913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68914       };
68915     } catch (std::exception& e) {
68916       {
68917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68918       };
68919     } catch (Dali::DaliException e) {
68920       {
68921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68922       };
68923     } catch (...) {
68924       {
68925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68926       };
68927     }
68928   }
68929
68930   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
68931
68932   //argout typemap for const std::string&
68933
68934   return jresult;
68935 }
68936
68937
68938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
68939   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
68940
68941   arg1 = (Dali::Toolkit::ImageView *)jarg1;
68942   {
68943     try {
68944       delete arg1;
68945     } catch (std::out_of_range& e) {
68946       {
68947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68948       };
68949     } catch (std::exception& e) {
68950       {
68951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68952       };
68953     } catch (Dali::DaliException e) {
68954       {
68955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68956       };
68957     } catch (...) {
68958       {
68959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68960       };
68961     }
68962   }
68963
68964 }
68965
68966
68967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
68968   void * jresult ;
68969   Dali::Toolkit::ImageView *arg1 = 0 ;
68970   Dali::Toolkit::ImageView *result = 0 ;
68971
68972   arg1 = (Dali::Toolkit::ImageView *)jarg1;
68973   if (!arg1) {
68974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
68975     return 0;
68976   }
68977   {
68978     try {
68979       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
68980     } catch (std::out_of_range& e) {
68981       {
68982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68983       };
68984     } catch (std::exception& e) {
68985       {
68986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68987       };
68988     } catch (Dali::DaliException e) {
68989       {
68990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68991       };
68992     } catch (...) {
68993       {
68994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68995       };
68996     }
68997   }
68998
68999   jresult = (void *)result;
69000   return jresult;
69001 }
69002
69003
69004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
69005   void * jresult ;
69006   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
69007   Dali::Toolkit::ImageView *arg2 = 0 ;
69008   Dali::Toolkit::ImageView *result = 0 ;
69009
69010   arg1 = (Dali::Toolkit::ImageView *)jarg1;
69011   arg2 = (Dali::Toolkit::ImageView *)jarg2;
69012   if (!arg2) {
69013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
69014     return 0;
69015   }
69016   {
69017     try {
69018       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
69019     } catch (std::out_of_range& e) {
69020       {
69021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69022       };
69023     } catch (std::exception& e) {
69024       {
69025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69026       };
69027     } catch (Dali::DaliException e) {
69028       {
69029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69030       };
69031     } catch (...) {
69032       {
69033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69034       };
69035     }
69036   }
69037
69038   jresult = (void *)result;
69039   return jresult;
69040 }
69041
69042
69043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
69044   void * jresult ;
69045   Dali::BaseHandle arg1 ;
69046   Dali::BaseHandle *argp1 ;
69047   Dali::Toolkit::ImageView result;
69048
69049   argp1 = (Dali::BaseHandle *)jarg1;
69050   if (!argp1) {
69051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69052     return 0;
69053   }
69054   arg1 = *argp1;
69055   {
69056     try {
69057       result = Dali::Toolkit::ImageView::DownCast(arg1);
69058     } catch (std::out_of_range& e) {
69059       {
69060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69061       };
69062     } catch (std::exception& e) {
69063       {
69064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69065       };
69066     } catch (Dali::DaliException e) {
69067       {
69068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69069       };
69070     } catch (...) {
69071       {
69072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69073       };
69074     }
69075   }
69076
69077   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
69078   return jresult;
69079 }
69080
69081
69082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
69083   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
69084   std::string *arg2 = 0 ;
69085
69086   arg1 = (Dali::Toolkit::ImageView *)jarg1;
69087   if (!jarg2) {
69088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69089     return ;
69090   }
69091   std::string arg2_str(jarg2);
69092   arg2 = &arg2_str;
69093   {
69094     try {
69095       (arg1)->SetImage((std::string const &)*arg2);
69096     } catch (std::out_of_range& e) {
69097       {
69098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69099       };
69100     } catch (std::exception& e) {
69101       {
69102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69103       };
69104     } catch (Dali::DaliException e) {
69105       {
69106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69107       };
69108     } catch (...) {
69109       {
69110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69111       };
69112     }
69113   }
69114
69115
69116   //argout typemap for const std::string&
69117
69118 }
69119
69120
69121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
69122   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
69123   std::string *arg2 = 0 ;
69124   Dali::ImageDimensions arg3 ;
69125   Dali::ImageDimensions *argp3 ;
69126
69127   arg1 = (Dali::Toolkit::ImageView *)jarg1;
69128   if (!jarg2) {
69129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69130     return ;
69131   }
69132   std::string arg2_str(jarg2);
69133   arg2 = &arg2_str;
69134   argp3 = (Dali::ImageDimensions *)jarg3;
69135   if (!argp3) {
69136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
69137     return ;
69138   }
69139   arg3 = *argp3;
69140   {
69141     try {
69142       (arg1)->SetImage((std::string const &)*arg2,arg3);
69143     } catch (std::out_of_range& e) {
69144       {
69145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69146       };
69147     } catch (std::exception& e) {
69148       {
69149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69150       };
69151     } catch (Dali::DaliException e) {
69152       {
69153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69154       };
69155     } catch (...) {
69156       {
69157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69158       };
69159     }
69160   }
69161
69162
69163   //argout typemap for const std::string&
69164
69165 }
69166
69167
69168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
69169   int jresult ;
69170   int result;
69171
69172   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
69173   jresult = (int)result;
69174   return jresult;
69175 }
69176
69177
69178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
69179   int jresult ;
69180   int result;
69181
69182   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
69183   jresult = (int)result;
69184   return jresult;
69185 }
69186
69187
69188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
69189   int jresult ;
69190   int result;
69191
69192   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
69193   jresult = (int)result;
69194   return jresult;
69195 }
69196
69197
69198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
69199   int jresult ;
69200   int result;
69201
69202   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
69203   jresult = (int)result;
69204   return jresult;
69205 }
69206
69207
69208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
69209   int jresult ;
69210   int result;
69211
69212   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
69213   jresult = (int)result;
69214   return jresult;
69215 }
69216
69217
69218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
69219   int jresult ;
69220   int result;
69221
69222   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
69223   jresult = (int)result;
69224   return jresult;
69225 }
69226
69227
69228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
69229   int jresult ;
69230   int result;
69231
69232   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
69233   jresult = (int)result;
69234   return jresult;
69235 }
69236
69237
69238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
69239   int jresult ;
69240   int result;
69241
69242   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
69243   jresult = (int)result;
69244   return jresult;
69245 }
69246
69247
69248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
69249   void * jresult ;
69250   Dali::Toolkit::Model3dView::Property *result = 0 ;
69251
69252   {
69253     try {
69254       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
69255     } catch (std::out_of_range& e) {
69256       {
69257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69258       };
69259     } catch (std::exception& e) {
69260       {
69261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69262       };
69263     } catch (Dali::DaliException e) {
69264       {
69265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69266       };
69267     } catch (...) {
69268       {
69269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69270       };
69271     }
69272   }
69273
69274   jresult = (void *)result;
69275   return jresult;
69276 }
69277
69278
69279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
69280   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
69281
69282   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
69283   {
69284     try {
69285       delete arg1;
69286     } catch (std::out_of_range& e) {
69287       {
69288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69289       };
69290     } catch (std::exception& e) {
69291       {
69292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69293       };
69294     } catch (Dali::DaliException e) {
69295       {
69296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69297       };
69298     } catch (...) {
69299       {
69300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69301       };
69302     }
69303   }
69304
69305 }
69306
69307
69308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
69309   void * jresult ;
69310   Dali::Toolkit::Model3dView result;
69311
69312   {
69313     try {
69314       result = Dali::Toolkit::Model3dView::New();
69315     } catch (std::out_of_range& e) {
69316       {
69317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69318       };
69319     } catch (std::exception& e) {
69320       {
69321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69322       };
69323     } catch (Dali::DaliException e) {
69324       {
69325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69326       };
69327     } catch (...) {
69328       {
69329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69330       };
69331     }
69332   }
69333
69334   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
69335   return jresult;
69336 }
69337
69338
69339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
69340   void * jresult ;
69341   std::string *arg1 = 0 ;
69342   std::string *arg2 = 0 ;
69343   std::string *arg3 = 0 ;
69344   Dali::Toolkit::Model3dView result;
69345
69346   if (!jarg1) {
69347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69348     return 0;
69349   }
69350   std::string arg1_str(jarg1);
69351   arg1 = &arg1_str;
69352   if (!jarg2) {
69353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69354     return 0;
69355   }
69356   std::string arg2_str(jarg2);
69357   arg2 = &arg2_str;
69358   if (!jarg3) {
69359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69360     return 0;
69361   }
69362   std::string arg3_str(jarg3);
69363   arg3 = &arg3_str;
69364   {
69365     try {
69366       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
69367     } catch (std::out_of_range& e) {
69368       {
69369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69370       };
69371     } catch (std::exception& e) {
69372       {
69373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69374       };
69375     } catch (Dali::DaliException e) {
69376       {
69377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69378       };
69379     } catch (...) {
69380       {
69381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69382       };
69383     }
69384   }
69385
69386   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
69387
69388   //argout typemap for const std::string&
69389
69390
69391   //argout typemap for const std::string&
69392
69393
69394   //argout typemap for const std::string&
69395
69396   return jresult;
69397 }
69398
69399
69400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
69401   void * jresult ;
69402   Dali::Toolkit::Model3dView *result = 0 ;
69403
69404   {
69405     try {
69406       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
69407     } catch (std::out_of_range& e) {
69408       {
69409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69410       };
69411     } catch (std::exception& e) {
69412       {
69413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69414       };
69415     } catch (Dali::DaliException e) {
69416       {
69417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69418       };
69419     } catch (...) {
69420       {
69421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69422       };
69423     }
69424   }
69425
69426   jresult = (void *)result;
69427   return jresult;
69428 }
69429
69430
69431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
69432   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
69433
69434   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
69435   {
69436     try {
69437       delete arg1;
69438     } catch (std::out_of_range& e) {
69439       {
69440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69441       };
69442     } catch (std::exception& e) {
69443       {
69444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69445       };
69446     } catch (Dali::DaliException e) {
69447       {
69448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69449       };
69450     } catch (...) {
69451       {
69452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69453       };
69454     }
69455   }
69456
69457 }
69458
69459
69460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
69461   void * jresult ;
69462   Dali::Toolkit::Model3dView *arg1 = 0 ;
69463   Dali::Toolkit::Model3dView *result = 0 ;
69464
69465   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
69466   if (!arg1) {
69467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
69468     return 0;
69469   }
69470   {
69471     try {
69472       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
69473     } catch (std::out_of_range& e) {
69474       {
69475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69476       };
69477     } catch (std::exception& e) {
69478       {
69479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69480       };
69481     } catch (Dali::DaliException e) {
69482       {
69483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69484       };
69485     } catch (...) {
69486       {
69487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69488       };
69489     }
69490   }
69491
69492   jresult = (void *)result;
69493   return jresult;
69494 }
69495
69496
69497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
69498   void * jresult ;
69499   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
69500   Dali::Toolkit::Model3dView *arg2 = 0 ;
69501   Dali::Toolkit::Model3dView *result = 0 ;
69502
69503   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
69504   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
69505   if (!arg2) {
69506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
69507     return 0;
69508   }
69509   {
69510     try {
69511       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
69512     } catch (std::out_of_range& e) {
69513       {
69514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69515       };
69516     } catch (std::exception& e) {
69517       {
69518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69519       };
69520     } catch (Dali::DaliException e) {
69521       {
69522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69523       };
69524     } catch (...) {
69525       {
69526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69527       };
69528     }
69529   }
69530
69531   jresult = (void *)result;
69532   return jresult;
69533 }
69534
69535
69536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
69537   void * jresult ;
69538   Dali::BaseHandle arg1 ;
69539   Dali::BaseHandle *argp1 ;
69540   Dali::Toolkit::Model3dView result;
69541
69542   argp1 = (Dali::BaseHandle *)jarg1;
69543   if (!argp1) {
69544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69545     return 0;
69546   }
69547   arg1 = *argp1;
69548   {
69549     try {
69550       result = Dali::Toolkit::Model3dView::DownCast(arg1);
69551     } catch (std::out_of_range& e) {
69552       {
69553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69554       };
69555     } catch (std::exception& e) {
69556       {
69557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69558       };
69559     } catch (Dali::DaliException e) {
69560       {
69561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69562       };
69563     } catch (...) {
69564       {
69565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69566       };
69567     }
69568   }
69569
69570   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
69571   return jresult;
69572 }
69573
69574
69575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
69576   int jresult ;
69577   int result;
69578
69579   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
69580   jresult = (int)result;
69581   return jresult;
69582 }
69583
69584
69585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
69586   int jresult ;
69587   int result;
69588
69589   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
69590   jresult = (int)result;
69591   return jresult;
69592 }
69593
69594
69595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
69596   int jresult ;
69597   int result;
69598
69599   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
69600   jresult = (int)result;
69601   return jresult;
69602 }
69603
69604
69605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
69606   int jresult ;
69607   int result;
69608
69609   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
69610   jresult = (int)result;
69611   return jresult;
69612 }
69613
69614
69615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
69616   int jresult ;
69617   int result;
69618
69619   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
69620   jresult = (int)result;
69621   return jresult;
69622 }
69623
69624
69625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
69626   int jresult ;
69627   int result;
69628
69629   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
69630   jresult = (int)result;
69631   return jresult;
69632 }
69633
69634
69635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
69636   int jresult ;
69637   int result;
69638
69639   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
69640   jresult = (int)result;
69641   return jresult;
69642 }
69643
69644
69645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
69646   int jresult ;
69647   int result;
69648
69649   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
69650   jresult = (int)result;
69651   return jresult;
69652 }
69653
69654
69655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
69656   int jresult ;
69657   int result;
69658
69659   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
69660   jresult = (int)result;
69661   return jresult;
69662 }
69663
69664
69665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
69666   void * jresult ;
69667   Dali::Toolkit::ScrollBar::Property *result = 0 ;
69668
69669   {
69670     try {
69671       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
69672     } catch (std::out_of_range& e) {
69673       {
69674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69675       };
69676     } catch (std::exception& e) {
69677       {
69678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69679       };
69680     } catch (Dali::DaliException e) {
69681       {
69682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69683       };
69684     } catch (...) {
69685       {
69686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69687       };
69688     }
69689   }
69690
69691   jresult = (void *)result;
69692   return jresult;
69693 }
69694
69695
69696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
69697   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
69698
69699   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
69700   {
69701     try {
69702       delete arg1;
69703     } catch (std::out_of_range& e) {
69704       {
69705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69706       };
69707     } catch (std::exception& e) {
69708       {
69709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69710       };
69711     } catch (Dali::DaliException e) {
69712       {
69713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69714       };
69715     } catch (...) {
69716       {
69717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69718       };
69719     }
69720   }
69721
69722 }
69723
69724
69725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
69726   void * jresult ;
69727   Dali::Toolkit::ScrollBar *result = 0 ;
69728
69729   {
69730     try {
69731       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
69732     } catch (std::out_of_range& e) {
69733       {
69734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69735       };
69736     } catch (std::exception& e) {
69737       {
69738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69739       };
69740     } catch (Dali::DaliException e) {
69741       {
69742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69743       };
69744     } catch (...) {
69745       {
69746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69747       };
69748     }
69749   }
69750
69751   jresult = (void *)result;
69752   return jresult;
69753 }
69754
69755
69756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
69757   void * jresult ;
69758   Dali::Toolkit::ScrollBar *arg1 = 0 ;
69759   Dali::Toolkit::ScrollBar *result = 0 ;
69760
69761   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69762   if (!arg1) {
69763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
69764     return 0;
69765   }
69766   {
69767     try {
69768       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
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 = (void *)result;
69789   return jresult;
69790 }
69791
69792
69793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
69794   void * jresult ;
69795   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69796   Dali::Toolkit::ScrollBar *arg2 = 0 ;
69797   Dali::Toolkit::ScrollBar *result = 0 ;
69798
69799   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69800   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
69801   if (!arg2) {
69802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
69803     return 0;
69804   }
69805   {
69806     try {
69807       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
69808     } catch (std::out_of_range& e) {
69809       {
69810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69811       };
69812     } catch (std::exception& e) {
69813       {
69814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69815       };
69816     } catch (Dali::DaliException e) {
69817       {
69818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69819       };
69820     } catch (...) {
69821       {
69822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69823       };
69824     }
69825   }
69826
69827   jresult = (void *)result;
69828   return jresult;
69829 }
69830
69831
69832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
69833   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69834
69835   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69836   {
69837     try {
69838       delete arg1;
69839     } catch (std::out_of_range& e) {
69840       {
69841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69842       };
69843     } catch (std::exception& e) {
69844       {
69845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69846       };
69847     } catch (Dali::DaliException e) {
69848       {
69849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69850       };
69851     } catch (...) {
69852       {
69853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69854       };
69855     }
69856   }
69857
69858 }
69859
69860
69861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
69862   void * jresult ;
69863   Dali::Toolkit::ScrollBar::Direction arg1 ;
69864   Dali::Toolkit::ScrollBar result;
69865
69866   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
69867   {
69868     try {
69869       result = Dali::Toolkit::ScrollBar::New(arg1);
69870     } catch (std::out_of_range& e) {
69871       {
69872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69873       };
69874     } catch (std::exception& e) {
69875       {
69876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69877       };
69878     } catch (Dali::DaliException e) {
69879       {
69880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69881       };
69882     } catch (...) {
69883       {
69884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69885       };
69886     }
69887   }
69888
69889   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
69890   return jresult;
69891 }
69892
69893
69894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
69895   void * jresult ;
69896   Dali::Toolkit::ScrollBar result;
69897
69898   {
69899     try {
69900       result = Dali::Toolkit::ScrollBar::New();
69901     } catch (std::out_of_range& e) {
69902       {
69903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69904       };
69905     } catch (std::exception& e) {
69906       {
69907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69908       };
69909     } catch (Dali::DaliException e) {
69910       {
69911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69912       };
69913     } catch (...) {
69914       {
69915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69916       };
69917     }
69918   }
69919
69920   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
69921   return jresult;
69922 }
69923
69924
69925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
69926   void * jresult ;
69927   Dali::BaseHandle arg1 ;
69928   Dali::BaseHandle *argp1 ;
69929   Dali::Toolkit::ScrollBar result;
69930
69931   argp1 = (Dali::BaseHandle *)jarg1;
69932   if (!argp1) {
69933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69934     return 0;
69935   }
69936   arg1 = *argp1;
69937   {
69938     try {
69939       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
69940     } catch (std::out_of_range& e) {
69941       {
69942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69943       };
69944     } catch (std::exception& e) {
69945       {
69946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69947       };
69948     } catch (Dali::DaliException e) {
69949       {
69950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69951       };
69952     } catch (...) {
69953       {
69954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69955       };
69956     }
69957   }
69958
69959   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
69960   return jresult;
69961 }
69962
69963
69964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
69965   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
69966   Dali::Handle arg2 ;
69967   Dali::Property::Index arg3 ;
69968   Dali::Property::Index arg4 ;
69969   Dali::Property::Index arg5 ;
69970   Dali::Property::Index arg6 ;
69971   Dali::Handle *argp2 ;
69972
69973   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
69974   argp2 = (Dali::Handle *)jarg2;
69975   if (!argp2) {
69976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
69977     return ;
69978   }
69979   arg2 = *argp2;
69980   arg3 = (Dali::Property::Index)jarg3;
69981   arg4 = (Dali::Property::Index)jarg4;
69982   arg5 = (Dali::Property::Index)jarg5;
69983   arg6 = (Dali::Property::Index)jarg6;
69984   {
69985     try {
69986       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
69987     } catch (std::out_of_range& e) {
69988       {
69989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69990       };
69991     } catch (std::exception& e) {
69992       {
69993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69994       };
69995     } catch (Dali::DaliException e) {
69996       {
69997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69998       };
69999     } catch (...) {
70000       {
70001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70002       };
70003     }
70004   }
70005
70006 }
70007
70008
70009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
70010   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70011   Dali::Actor arg2 ;
70012   Dali::Actor *argp2 ;
70013
70014   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70015   argp2 = (Dali::Actor *)jarg2;
70016   if (!argp2) {
70017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70018     return ;
70019   }
70020   arg2 = *argp2;
70021   {
70022     try {
70023       (arg1)->SetScrollIndicator(arg2);
70024     } catch (std::out_of_range& e) {
70025       {
70026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70027       };
70028     } catch (std::exception& e) {
70029       {
70030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70031       };
70032     } catch (Dali::DaliException e) {
70033       {
70034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70035       };
70036     } catch (...) {
70037       {
70038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70039       };
70040     }
70041   }
70042
70043 }
70044
70045
70046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
70047   void * jresult ;
70048   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70049   Dali::Actor result;
70050
70051   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70052   {
70053     try {
70054       result = (arg1)->GetScrollIndicator();
70055     } catch (std::out_of_range& e) {
70056       {
70057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70058       };
70059     } catch (std::exception& e) {
70060       {
70061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70062       };
70063     } catch (Dali::DaliException e) {
70064       {
70065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70066       };
70067     } catch (...) {
70068       {
70069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70070       };
70071     }
70072   }
70073
70074   jresult = new Dali::Actor((const Dali::Actor &)result);
70075   return jresult;
70076 }
70077
70078
70079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
70080   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70081   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
70082
70083   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70084   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
70085   if (!arg2) {
70086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
70087     return ;
70088   }
70089   {
70090     try {
70091       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
70092     } catch (std::out_of_range& e) {
70093       {
70094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70095       };
70096     } catch (std::exception& e) {
70097       {
70098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70099       };
70100     } catch (Dali::DaliException e) {
70101       {
70102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70103       };
70104     } catch (...) {
70105       {
70106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70107       };
70108     }
70109   }
70110
70111 }
70112
70113
70114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
70115   void * jresult ;
70116   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70117
70118   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70119   {
70120     try {
70121       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()));
70122     } catch (std::out_of_range& e) {
70123       {
70124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70125       };
70126     } catch (std::exception& e) {
70127       {
70128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70129       };
70130     } catch (...) {
70131       {
70132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70133       };
70134     }
70135   }
70136   return jresult;
70137 }
70138
70139
70140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
70141   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70142   Dali::Toolkit::ScrollBar::Direction arg2 ;
70143
70144   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70145   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
70146   {
70147     try {
70148       (arg1)->SetScrollDirection(arg2);
70149     } catch (std::out_of_range& e) {
70150       {
70151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70152       };
70153     } catch (std::exception& e) {
70154       {
70155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70156       };
70157     } catch (Dali::DaliException e) {
70158       {
70159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70160       };
70161     } catch (...) {
70162       {
70163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70164       };
70165     }
70166   }
70167
70168 }
70169
70170
70171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
70172   int jresult ;
70173   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70174   Dali::Toolkit::ScrollBar::Direction result;
70175
70176   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70177   {
70178     try {
70179       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
70180     } catch (std::out_of_range& e) {
70181       {
70182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70183       };
70184     } catch (std::exception& e) {
70185       {
70186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70187       };
70188     } catch (Dali::DaliException e) {
70189       {
70190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70191       };
70192     } catch (...) {
70193       {
70194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70195       };
70196     }
70197   }
70198
70199   jresult = (int)result;
70200   return jresult;
70201 }
70202
70203
70204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
70205   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70206   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
70207
70208   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70209   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
70210   {
70211     try {
70212       (arg1)->SetIndicatorHeightPolicy(arg2);
70213     } catch (std::out_of_range& e) {
70214       {
70215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70216       };
70217     } catch (std::exception& e) {
70218       {
70219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70220       };
70221     } catch (Dali::DaliException e) {
70222       {
70223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70224       };
70225     } catch (...) {
70226       {
70227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70228       };
70229     }
70230   }
70231
70232 }
70233
70234
70235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
70236   int jresult ;
70237   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70238   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
70239
70240   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70241   {
70242     try {
70243       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
70244     } catch (std::out_of_range& e) {
70245       {
70246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70247       };
70248     } catch (std::exception& e) {
70249       {
70250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70251       };
70252     } catch (Dali::DaliException e) {
70253       {
70254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70255       };
70256     } catch (...) {
70257       {
70258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70259       };
70260     }
70261   }
70262
70263   jresult = (int)result;
70264   return jresult;
70265 }
70266
70267
70268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
70269   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70270   float arg2 ;
70271
70272   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70273   arg2 = (float)jarg2;
70274   {
70275     try {
70276       (arg1)->SetIndicatorFixedHeight(arg2);
70277     } catch (std::out_of_range& e) {
70278       {
70279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70280       };
70281     } catch (std::exception& e) {
70282       {
70283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70284       };
70285     } catch (Dali::DaliException e) {
70286       {
70287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70288       };
70289     } catch (...) {
70290       {
70291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70292       };
70293     }
70294   }
70295
70296 }
70297
70298
70299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
70300   float jresult ;
70301   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70302   float result;
70303
70304   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70305   {
70306     try {
70307       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
70308     } catch (std::out_of_range& e) {
70309       {
70310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70311       };
70312     } catch (std::exception& e) {
70313       {
70314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70315       };
70316     } catch (Dali::DaliException e) {
70317       {
70318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70319       };
70320     } catch (...) {
70321       {
70322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70323       };
70324     }
70325   }
70326
70327   jresult = result;
70328   return jresult;
70329 }
70330
70331
70332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
70333   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70334   float arg2 ;
70335
70336   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70337   arg2 = (float)jarg2;
70338   {
70339     try {
70340       (arg1)->SetIndicatorShowDuration(arg2);
70341     } catch (std::out_of_range& e) {
70342       {
70343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70344       };
70345     } catch (std::exception& e) {
70346       {
70347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70348       };
70349     } catch (Dali::DaliException e) {
70350       {
70351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70352       };
70353     } catch (...) {
70354       {
70355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70356       };
70357     }
70358   }
70359
70360 }
70361
70362
70363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
70364   float jresult ;
70365   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70366   float result;
70367
70368   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70369   {
70370     try {
70371       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
70372     } catch (std::out_of_range& e) {
70373       {
70374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70375       };
70376     } catch (std::exception& e) {
70377       {
70378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70379       };
70380     } catch (Dali::DaliException e) {
70381       {
70382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70383       };
70384     } catch (...) {
70385       {
70386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70387       };
70388     }
70389   }
70390
70391   jresult = result;
70392   return jresult;
70393 }
70394
70395
70396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
70397   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70398   float arg2 ;
70399
70400   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70401   arg2 = (float)jarg2;
70402   {
70403     try {
70404       (arg1)->SetIndicatorHideDuration(arg2);
70405     } catch (std::out_of_range& e) {
70406       {
70407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70408       };
70409     } catch (std::exception& e) {
70410       {
70411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70412       };
70413     } catch (Dali::DaliException e) {
70414       {
70415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70416       };
70417     } catch (...) {
70418       {
70419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70420       };
70421     }
70422   }
70423
70424 }
70425
70426
70427 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
70428   float jresult ;
70429   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70430   float result;
70431
70432   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70433   {
70434     try {
70435       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
70436     } catch (std::out_of_range& e) {
70437       {
70438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70439       };
70440     } catch (std::exception& e) {
70441       {
70442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70443       };
70444     } catch (Dali::DaliException e) {
70445       {
70446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70447       };
70448     } catch (...) {
70449       {
70450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70451       };
70452     }
70453   }
70454
70455   jresult = result;
70456   return jresult;
70457 }
70458
70459
70460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
70461   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70462
70463   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70464   {
70465     try {
70466       (arg1)->ShowIndicator();
70467     } catch (std::out_of_range& e) {
70468       {
70469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70470       };
70471     } catch (std::exception& e) {
70472       {
70473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70474       };
70475     } catch (Dali::DaliException e) {
70476       {
70477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70478       };
70479     } catch (...) {
70480       {
70481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70482       };
70483     }
70484   }
70485
70486 }
70487
70488
70489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
70490   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70491
70492   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70493   {
70494     try {
70495       (arg1)->HideIndicator();
70496     } catch (std::out_of_range& e) {
70497       {
70498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70499       };
70500     } catch (std::exception& e) {
70501       {
70502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70503       };
70504     } catch (Dali::DaliException e) {
70505       {
70506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70507       };
70508     } catch (...) {
70509       {
70510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70511       };
70512     }
70513   }
70514
70515 }
70516
70517
70518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
70519   void * jresult ;
70520   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70521   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
70522
70523   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70524   {
70525     try {
70526       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
70527     } catch (std::out_of_range& e) {
70528       {
70529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70530       };
70531     } catch (std::exception& e) {
70532       {
70533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70534       };
70535     } catch (Dali::DaliException e) {
70536       {
70537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70538       };
70539     } catch (...) {
70540       {
70541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70542       };
70543     }
70544   }
70545
70546   jresult = (void *)result;
70547   return jresult;
70548 }
70549
70550
70551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
70552   void * jresult ;
70553   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70554   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
70555
70556   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70557   {
70558     try {
70559       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
70560     } catch (std::out_of_range& e) {
70561       {
70562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70563       };
70564     } catch (std::exception& e) {
70565       {
70566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70567       };
70568     } catch (Dali::DaliException e) {
70569       {
70570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70571       };
70572     } catch (...) {
70573       {
70574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70575       };
70576     }
70577   }
70578
70579   jresult = (void *)result;
70580   return jresult;
70581 }
70582
70583
70584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
70585   int jresult ;
70586   int result;
70587
70588   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
70589   jresult = (int)result;
70590   return jresult;
70591 }
70592
70593
70594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
70595   int jresult ;
70596   int result;
70597
70598   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
70599   jresult = (int)result;
70600   return jresult;
70601 }
70602
70603
70604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
70605   int jresult ;
70606   int result;
70607
70608   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
70609   jresult = (int)result;
70610   return jresult;
70611 }
70612
70613
70614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
70615   int jresult ;
70616   int result;
70617
70618   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
70619   jresult = (int)result;
70620   return jresult;
70621 }
70622
70623
70624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
70625   int jresult ;
70626   int result;
70627
70628   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
70629   jresult = (int)result;
70630   return jresult;
70631 }
70632
70633
70634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
70635   int jresult ;
70636   int result;
70637
70638   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
70639   jresult = (int)result;
70640   return jresult;
70641 }
70642
70643
70644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
70645   int jresult ;
70646   int result;
70647
70648   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
70649   jresult = (int)result;
70650   return jresult;
70651 }
70652
70653
70654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
70655   int jresult ;
70656   int result;
70657
70658   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
70659   jresult = (int)result;
70660   return jresult;
70661 }
70662
70663
70664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
70665   int jresult ;
70666   int result;
70667
70668   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
70669   jresult = (int)result;
70670   return jresult;
70671 }
70672
70673
70674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
70675   int jresult ;
70676   int result;
70677
70678   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
70679   jresult = (int)result;
70680   return jresult;
70681 }
70682
70683
70684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
70685   int jresult ;
70686   int result;
70687
70688   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
70689   jresult = (int)result;
70690   return jresult;
70691 }
70692
70693
70694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
70695   int jresult ;
70696   int result;
70697
70698   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
70699   jresult = (int)result;
70700   return jresult;
70701 }
70702
70703
70704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
70705   int jresult ;
70706   int result;
70707
70708   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
70709   jresult = (int)result;
70710   return jresult;
70711 }
70712
70713
70714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
70715   int jresult ;
70716   int result;
70717
70718   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
70719   jresult = (int)result;
70720   return jresult;
70721 }
70722
70723
70724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
70725   void * jresult ;
70726   Dali::Toolkit::Scrollable::Property *result = 0 ;
70727
70728   {
70729     try {
70730       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
70731     } catch (std::out_of_range& e) {
70732       {
70733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70734       };
70735     } catch (std::exception& e) {
70736       {
70737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70738       };
70739     } catch (Dali::DaliException e) {
70740       {
70741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70742       };
70743     } catch (...) {
70744       {
70745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70746       };
70747     }
70748   }
70749
70750   jresult = (void *)result;
70751   return jresult;
70752 }
70753
70754
70755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
70756   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
70757
70758   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
70759   {
70760     try {
70761       delete arg1;
70762     } catch (std::out_of_range& e) {
70763       {
70764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70765       };
70766     } catch (std::exception& e) {
70767       {
70768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70769       };
70770     } catch (Dali::DaliException e) {
70771       {
70772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70773       };
70774     } catch (...) {
70775       {
70776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70777       };
70778     }
70779   }
70780
70781 }
70782
70783
70784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
70785   void * jresult ;
70786   Dali::Toolkit::Scrollable *result = 0 ;
70787
70788   {
70789     try {
70790       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
70791     } catch (std::out_of_range& e) {
70792       {
70793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70794       };
70795     } catch (std::exception& e) {
70796       {
70797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70798       };
70799     } catch (Dali::DaliException e) {
70800       {
70801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70802       };
70803     } catch (...) {
70804       {
70805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70806       };
70807     }
70808   }
70809
70810   jresult = (void *)result;
70811   return jresult;
70812 }
70813
70814
70815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
70816   void * jresult ;
70817   Dali::Toolkit::Scrollable *arg1 = 0 ;
70818   Dali::Toolkit::Scrollable *result = 0 ;
70819
70820   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70821   if (!arg1) {
70822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
70823     return 0;
70824   }
70825   {
70826     try {
70827       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
70828     } catch (std::out_of_range& e) {
70829       {
70830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70831       };
70832     } catch (std::exception& e) {
70833       {
70834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70835       };
70836     } catch (Dali::DaliException e) {
70837       {
70838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70839       };
70840     } catch (...) {
70841       {
70842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70843       };
70844     }
70845   }
70846
70847   jresult = (void *)result;
70848   return jresult;
70849 }
70850
70851
70852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
70853   void * jresult ;
70854   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70855   Dali::Toolkit::Scrollable *arg2 = 0 ;
70856   Dali::Toolkit::Scrollable *result = 0 ;
70857
70858   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70859   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
70860   if (!arg2) {
70861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
70862     return 0;
70863   }
70864   {
70865     try {
70866       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
70867     } catch (std::out_of_range& e) {
70868       {
70869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70870       };
70871     } catch (std::exception& e) {
70872       {
70873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70874       };
70875     } catch (Dali::DaliException e) {
70876       {
70877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70878       };
70879     } catch (...) {
70880       {
70881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70882       };
70883     }
70884   }
70885
70886   jresult = (void *)result;
70887   return jresult;
70888 }
70889
70890
70891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
70892   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70893
70894   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70895   {
70896     try {
70897       delete arg1;
70898     } catch (std::out_of_range& e) {
70899       {
70900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70901       };
70902     } catch (std::exception& e) {
70903       {
70904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70905       };
70906     } catch (Dali::DaliException e) {
70907       {
70908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70909       };
70910     } catch (...) {
70911       {
70912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70913       };
70914     }
70915   }
70916
70917 }
70918
70919
70920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
70921   void * jresult ;
70922   Dali::BaseHandle arg1 ;
70923   Dali::BaseHandle *argp1 ;
70924   Dali::Toolkit::Scrollable result;
70925
70926   argp1 = (Dali::BaseHandle *)jarg1;
70927   if (!argp1) {
70928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70929     return 0;
70930   }
70931   arg1 = *argp1;
70932   {
70933     try {
70934       result = Dali::Toolkit::Scrollable::DownCast(arg1);
70935     } catch (std::out_of_range& e) {
70936       {
70937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70938       };
70939     } catch (std::exception& e) {
70940       {
70941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70942       };
70943     } catch (Dali::DaliException e) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70946       };
70947     } catch (...) {
70948       {
70949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70950       };
70951     }
70952   }
70953
70954   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
70955   return jresult;
70956 }
70957
70958
70959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
70960   unsigned int jresult ;
70961   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70962   bool result;
70963
70964   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70965   {
70966     try {
70967       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
70968     } catch (std::out_of_range& e) {
70969       {
70970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70971       };
70972     } catch (std::exception& e) {
70973       {
70974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70975       };
70976     } catch (Dali::DaliException e) {
70977       {
70978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70979       };
70980     } catch (...) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70983       };
70984     }
70985   }
70986
70987   jresult = result;
70988   return jresult;
70989 }
70990
70991
70992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
70993   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
70994   bool arg2 ;
70995
70996   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
70997   arg2 = jarg2 ? true : false;
70998   {
70999     try {
71000       (arg1)->SetOvershootEnabled(arg2);
71001     } catch (std::out_of_range& e) {
71002       {
71003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71004       };
71005     } catch (std::exception& e) {
71006       {
71007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71008       };
71009     } catch (Dali::DaliException e) {
71010       {
71011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71012       };
71013     } catch (...) {
71014       {
71015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71016       };
71017     }
71018   }
71019
71020 }
71021
71022
71023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
71024   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71025   Dali::Vector4 *arg2 = 0 ;
71026
71027   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71028   arg2 = (Dali::Vector4 *)jarg2;
71029   if (!arg2) {
71030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
71031     return ;
71032   }
71033   {
71034     try {
71035       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
71036     } catch (std::out_of_range& e) {
71037       {
71038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71039       };
71040     } catch (std::exception& e) {
71041       {
71042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71043       };
71044     } catch (Dali::DaliException e) {
71045       {
71046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71047       };
71048     } catch (...) {
71049       {
71050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71051       };
71052     }
71053   }
71054
71055 }
71056
71057
71058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
71059   void * jresult ;
71060   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71061   Dali::Vector4 result;
71062
71063   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71064   {
71065     try {
71066       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
71067     } catch (std::out_of_range& e) {
71068       {
71069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71070       };
71071     } catch (std::exception& e) {
71072       {
71073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71074       };
71075     } catch (Dali::DaliException e) {
71076       {
71077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71078       };
71079     } catch (...) {
71080       {
71081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71082       };
71083     }
71084   }
71085
71086   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
71087   return jresult;
71088 }
71089
71090
71091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
71092   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71093   float arg2 ;
71094
71095   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71096   arg2 = (float)jarg2;
71097   {
71098     try {
71099       (arg1)->SetOvershootAnimationSpeed(arg2);
71100     } catch (std::out_of_range& e) {
71101       {
71102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71103       };
71104     } catch (std::exception& e) {
71105       {
71106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71107       };
71108     } catch (Dali::DaliException e) {
71109       {
71110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71111       };
71112     } catch (...) {
71113       {
71114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71115       };
71116     }
71117   }
71118
71119 }
71120
71121
71122 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
71123   float jresult ;
71124   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71125   float result;
71126
71127   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71128   {
71129     try {
71130       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
71131     } catch (std::out_of_range& e) {
71132       {
71133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71134       };
71135     } catch (std::exception& e) {
71136       {
71137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71138       };
71139     } catch (Dali::DaliException e) {
71140       {
71141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71142       };
71143     } catch (...) {
71144       {
71145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71146       };
71147     }
71148   }
71149
71150   jresult = result;
71151   return jresult;
71152 }
71153
71154
71155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
71156   void * jresult ;
71157   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71158   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
71159
71160   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71161   {
71162     try {
71163       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
71164     } catch (std::out_of_range& e) {
71165       {
71166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71167       };
71168     } catch (std::exception& e) {
71169       {
71170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71171       };
71172     } catch (Dali::DaliException e) {
71173       {
71174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71175       };
71176     } catch (...) {
71177       {
71178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71179       };
71180     }
71181   }
71182
71183   jresult = (void *)result;
71184   return jresult;
71185 }
71186
71187
71188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
71189   void * jresult ;
71190   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71191   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
71192
71193   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71194   {
71195     try {
71196       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
71197     } catch (std::out_of_range& e) {
71198       {
71199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71200       };
71201     } catch (std::exception& e) {
71202       {
71203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71204       };
71205     } catch (Dali::DaliException e) {
71206       {
71207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71208       };
71209     } catch (...) {
71210       {
71211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71212       };
71213     }
71214   }
71215
71216   jresult = (void *)result;
71217   return jresult;
71218 }
71219
71220
71221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
71222   void * jresult ;
71223   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71224   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
71225
71226   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71227   {
71228     try {
71229       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
71230     } catch (std::out_of_range& e) {
71231       {
71232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71233       };
71234     } catch (std::exception& e) {
71235       {
71236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71237       };
71238     } catch (Dali::DaliException e) {
71239       {
71240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71241       };
71242     } catch (...) {
71243       {
71244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71245       };
71246     }
71247   }
71248
71249   jresult = (void *)result;
71250   return jresult;
71251 }
71252
71253
71254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
71255   unsigned int jresult ;
71256   Dali::Toolkit::ControlOrientation::Type arg1 ;
71257   bool result;
71258
71259   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
71260   {
71261     try {
71262       result = (bool)Dali::Toolkit::IsVertical(arg1);
71263     } catch (std::out_of_range& e) {
71264       {
71265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71266       };
71267     } catch (std::exception& e) {
71268       {
71269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71270       };
71271     } catch (Dali::DaliException e) {
71272       {
71273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71274       };
71275     } catch (...) {
71276       {
71277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71278       };
71279     }
71280   }
71281
71282   jresult = result;
71283   return jresult;
71284 }
71285
71286
71287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
71288   unsigned int jresult ;
71289   Dali::Toolkit::ControlOrientation::Type arg1 ;
71290   bool result;
71291
71292   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
71293   {
71294     try {
71295       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
71296     } catch (std::out_of_range& e) {
71297       {
71298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71299       };
71300     } catch (std::exception& e) {
71301       {
71302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71303       };
71304     } catch (Dali::DaliException e) {
71305       {
71306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71307       };
71308     } catch (...) {
71309       {
71310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71311       };
71312     }
71313   }
71314
71315   jresult = result;
71316   return jresult;
71317 }
71318
71319
71320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
71321   void * jresult ;
71322   unsigned int arg1 ;
71323   unsigned int arg2 ;
71324   Dali::Toolkit::ItemRange *result = 0 ;
71325
71326   arg1 = (unsigned int)jarg1;
71327   arg2 = (unsigned int)jarg2;
71328   {
71329     try {
71330       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
71331     } catch (std::out_of_range& e) {
71332       {
71333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71334       };
71335     } catch (std::exception& e) {
71336       {
71337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71338       };
71339     } catch (Dali::DaliException e) {
71340       {
71341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71342       };
71343     } catch (...) {
71344       {
71345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71346       };
71347     }
71348   }
71349
71350   jresult = (void *)result;
71351   return jresult;
71352 }
71353
71354
71355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
71356   void * jresult ;
71357   Dali::Toolkit::ItemRange *arg1 = 0 ;
71358   Dali::Toolkit::ItemRange *result = 0 ;
71359
71360   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
71361   if (!arg1) {
71362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
71363     return 0;
71364   }
71365   {
71366     try {
71367       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
71368     } catch (std::out_of_range& e) {
71369       {
71370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71371       };
71372     } catch (std::exception& e) {
71373       {
71374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71375       };
71376     } catch (Dali::DaliException e) {
71377       {
71378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71379       };
71380     } catch (...) {
71381       {
71382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71383       };
71384     }
71385   }
71386
71387   jresult = (void *)result;
71388   return jresult;
71389 }
71390
71391
71392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
71393   void * jresult ;
71394   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
71395   Dali::Toolkit::ItemRange *arg2 = 0 ;
71396   Dali::Toolkit::ItemRange *result = 0 ;
71397
71398   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
71399   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71400   if (!arg2) {
71401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
71402     return 0;
71403   }
71404   {
71405     try {
71406       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
71407     } catch (std::out_of_range& e) {
71408       {
71409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71410       };
71411     } catch (std::exception& e) {
71412       {
71413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71414       };
71415     } catch (Dali::DaliException e) {
71416       {
71417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71418       };
71419     } catch (...) {
71420       {
71421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71422       };
71423     }
71424   }
71425
71426   jresult = (void *)result;
71427   return jresult;
71428 }
71429
71430
71431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
71432   unsigned int jresult ;
71433   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
71434   unsigned int arg2 ;
71435   bool result;
71436
71437   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
71438   arg2 = (unsigned int)jarg2;
71439   {
71440     try {
71441       result = (bool)(arg1)->Within(arg2);
71442     } catch (std::out_of_range& e) {
71443       {
71444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71445       };
71446     } catch (std::exception& e) {
71447       {
71448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71449       };
71450     } catch (Dali::DaliException e) {
71451       {
71452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71453       };
71454     } catch (...) {
71455       {
71456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71457       };
71458     }
71459   }
71460
71461   jresult = result;
71462   return jresult;
71463 }
71464
71465
71466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
71467   void * jresult ;
71468   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
71469   Dali::Toolkit::ItemRange *arg2 = 0 ;
71470   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
71471
71472   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
71473   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71474   if (!arg2) {
71475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
71476     return 0;
71477   }
71478   {
71479     try {
71480       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
71481     } catch (std::out_of_range& e) {
71482       {
71483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71484       };
71485     } catch (std::exception& e) {
71486       {
71487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71488       };
71489     } catch (Dali::DaliException e) {
71490       {
71491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71492       };
71493     } catch (...) {
71494       {
71495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71496       };
71497     }
71498   }
71499
71500   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
71501   return jresult;
71502 }
71503
71504
71505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
71506   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
71507   unsigned int arg2 ;
71508
71509   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
71510   arg2 = (unsigned int)jarg2;
71511   if (arg1) (arg1)->begin = arg2;
71512 }
71513
71514
71515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
71516   unsigned int jresult ;
71517   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
71518   unsigned int result;
71519
71520   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
71521   result = (unsigned int) ((arg1)->begin);
71522   jresult = result;
71523   return jresult;
71524 }
71525
71526
71527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
71528   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
71529   unsigned int arg2 ;
71530
71531   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
71532   arg2 = (unsigned int)jarg2;
71533   if (arg1) (arg1)->end = arg2;
71534 }
71535
71536
71537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
71538   unsigned int jresult ;
71539   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
71540   unsigned int result;
71541
71542   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
71543   result = (unsigned int) ((arg1)->end);
71544   jresult = result;
71545   return jresult;
71546 }
71547
71548
71549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
71550   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
71551
71552   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
71553   {
71554     try {
71555       delete arg1;
71556     } catch (std::out_of_range& e) {
71557       {
71558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71559       };
71560     } catch (std::exception& e) {
71561       {
71562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71563       };
71564     } catch (Dali::DaliException e) {
71565       {
71566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71567       };
71568     } catch (...) {
71569       {
71570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71571       };
71572     }
71573   }
71574
71575 }
71576
71577
71578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
71579   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71580
71581   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71582   {
71583     try {
71584       delete arg1;
71585     } catch (std::out_of_range& e) {
71586       {
71587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71588       };
71589     } catch (std::exception& e) {
71590       {
71591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71592       };
71593     } catch (Dali::DaliException e) {
71594       {
71595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71596       };
71597     } catch (...) {
71598       {
71599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71600       };
71601     }
71602   }
71603
71604 }
71605
71606
71607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
71608   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71609   Dali::Toolkit::ControlOrientation::Type arg2 ;
71610
71611   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71612   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
71613   {
71614     try {
71615       (arg1)->SetOrientation(arg2);
71616     } catch (std::out_of_range& e) {
71617       {
71618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71619       };
71620     } catch (std::exception& e) {
71621       {
71622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71623       };
71624     } catch (Dali::DaliException e) {
71625       {
71626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71627       };
71628     } catch (...) {
71629       {
71630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71631       };
71632     }
71633   }
71634
71635 }
71636
71637
71638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
71639   int jresult ;
71640   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71641   Dali::Toolkit::ControlOrientation::Type result;
71642
71643   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71644   {
71645     try {
71646       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
71647     } catch (std::out_of_range& e) {
71648       {
71649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71650       };
71651     } catch (std::exception& e) {
71652       {
71653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71654       };
71655     } catch (Dali::DaliException e) {
71656       {
71657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71658       };
71659     } catch (...) {
71660       {
71661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71662       };
71663     }
71664   }
71665
71666   jresult = (int)result;
71667   return jresult;
71668 }
71669
71670
71671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
71672   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71673   Dali::Property::Map *arg2 = 0 ;
71674
71675   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71676   arg2 = (Dali::Property::Map *)jarg2;
71677   if (!arg2) {
71678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
71679     return ;
71680   }
71681   {
71682     try {
71683       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
71684     } catch (std::out_of_range& e) {
71685       {
71686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71687       };
71688     } catch (std::exception& e) {
71689       {
71690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71691       };
71692     } catch (Dali::DaliException e) {
71693       {
71694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71695       };
71696     } catch (...) {
71697       {
71698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71699       };
71700     }
71701   }
71702
71703 }
71704
71705
71706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
71707   void * jresult ;
71708   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71709   Dali::Property::Map result;
71710
71711   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71712   {
71713     try {
71714       result = (arg1)->GetLayoutProperties();
71715     } catch (std::out_of_range& e) {
71716       {
71717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71718       };
71719     } catch (std::exception& e) {
71720       {
71721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71722       };
71723     } catch (Dali::DaliException e) {
71724       {
71725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71726       };
71727     } catch (...) {
71728       {
71729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71730       };
71731     }
71732   }
71733
71734   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
71735   return jresult;
71736 }
71737
71738
71739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
71740   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71741   unsigned int arg2 ;
71742   Dali::Vector3 *arg3 = 0 ;
71743   Dali::Vector3 *arg4 = 0 ;
71744
71745   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71746   arg2 = (unsigned int)jarg2;
71747   arg3 = (Dali::Vector3 *)jarg3;
71748   if (!arg3) {
71749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71750     return ;
71751   }
71752   arg4 = (Dali::Vector3 *)jarg4;
71753   if (!arg4) {
71754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71755     return ;
71756   }
71757   {
71758     try {
71759       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
71760     } catch (std::out_of_range& e) {
71761       {
71762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71763       };
71764     } catch (std::exception& e) {
71765       {
71766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71767       };
71768     } catch (Dali::DaliException e) {
71769       {
71770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71771       };
71772     } catch (...) {
71773       {
71774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71775       };
71776     }
71777   }
71778
71779 }
71780
71781
71782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
71783   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71784   Dali::Vector3 *arg2 = 0 ;
71785
71786   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71787   arg2 = (Dali::Vector3 *)jarg2;
71788   if (!arg2) {
71789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71790     return ;
71791   }
71792   {
71793     try {
71794       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
71795     } catch (std::out_of_range& e) {
71796       {
71797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71798       };
71799     } catch (std::exception& e) {
71800       {
71801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71802       };
71803     } catch (Dali::DaliException e) {
71804       {
71805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71806       };
71807     } catch (...) {
71808       {
71809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71810       };
71811     }
71812   }
71813
71814 }
71815
71816
71817 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
71818   float jresult ;
71819   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71820   unsigned int arg2 ;
71821   Dali::Vector3 arg3 ;
71822   Dali::Vector3 *argp3 ;
71823   float result;
71824
71825   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71826   arg2 = (unsigned int)jarg2;
71827   argp3 = (Dali::Vector3 *)jarg3;
71828   if (!argp3) {
71829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71830     return 0;
71831   }
71832   arg3 = *argp3;
71833   {
71834     try {
71835       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
71836     } catch (std::out_of_range& e) {
71837       {
71838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71839       };
71840     } catch (std::exception& e) {
71841       {
71842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71843       };
71844     } catch (Dali::DaliException e) {
71845       {
71846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71847       };
71848     } catch (...) {
71849       {
71850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71851       };
71852     }
71853   }
71854
71855   jresult = result;
71856   return jresult;
71857 }
71858
71859
71860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
71861   float jresult ;
71862   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71863   float arg2 ;
71864   float result;
71865
71866   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71867   arg2 = (float)jarg2;
71868   {
71869     try {
71870       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
71871     } catch (std::out_of_range& e) {
71872       {
71873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71874       };
71875     } catch (std::exception& e) {
71876       {
71877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71878       };
71879     } catch (Dali::DaliException e) {
71880       {
71881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71882       };
71883     } catch (...) {
71884       {
71885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71886       };
71887     }
71888   }
71889
71890   jresult = result;
71891   return jresult;
71892 }
71893
71894
71895 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
71896   float jresult ;
71897   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71898   unsigned int arg2 ;
71899   float result;
71900
71901   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71902   arg2 = (unsigned int)jarg2;
71903   {
71904     try {
71905       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
71906     } catch (std::out_of_range& e) {
71907       {
71908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71909       };
71910     } catch (std::exception& e) {
71911       {
71912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71913       };
71914     } catch (Dali::DaliException e) {
71915       {
71916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71917       };
71918     } catch (...) {
71919       {
71920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71921       };
71922     }
71923   }
71924
71925   jresult = result;
71926   return jresult;
71927 }
71928
71929
71930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
71931   void * jresult ;
71932   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71933   float arg2 ;
71934   Dali::Vector3 arg3 ;
71935   Dali::Vector3 *argp3 ;
71936   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
71937
71938   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71939   arg2 = (float)jarg2;
71940   argp3 = (Dali::Vector3 *)jarg3;
71941   if (!argp3) {
71942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71943     return 0;
71944   }
71945   arg3 = *argp3;
71946   {
71947     try {
71948       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
71949     } catch (std::out_of_range& e) {
71950       {
71951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71952       };
71953     } catch (std::exception& e) {
71954       {
71955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71956       };
71957     } catch (Dali::DaliException e) {
71958       {
71959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71960       };
71961     } catch (...) {
71962       {
71963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71964       };
71965     }
71966   }
71967
71968   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
71969   return jresult;
71970 }
71971
71972
71973 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
71974   float jresult ;
71975   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
71976   int arg2 ;
71977   float arg3 ;
71978   Dali::Vector3 *arg4 = 0 ;
71979   float result;
71980
71981   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
71982   arg2 = (int)jarg2;
71983   arg3 = (float)jarg3;
71984   arg4 = (Dali::Vector3 *)jarg4;
71985   if (!arg4) {
71986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71987     return 0;
71988   }
71989   {
71990     try {
71991       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
71992     } catch (std::out_of_range& e) {
71993       {
71994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71995       };
71996     } catch (std::exception& e) {
71997       {
71998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71999       };
72000     } catch (Dali::DaliException e) {
72001       {
72002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72003       };
72004     } catch (...) {
72005       {
72006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72007       };
72008     }
72009   }
72010
72011   jresult = result;
72012   return jresult;
72013 }
72014
72015
72016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
72017   unsigned int jresult ;
72018   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72019   Dali::Vector3 arg2 ;
72020   Dali::Vector3 *argp2 ;
72021   unsigned int result;
72022
72023   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72024   argp2 = (Dali::Vector3 *)jarg2;
72025   if (!argp2) {
72026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
72027     return 0;
72028   }
72029   arg2 = *argp2;
72030   {
72031     try {
72032       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
72033     } catch (std::out_of_range& e) {
72034       {
72035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72036       };
72037     } catch (std::exception& e) {
72038       {
72039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72040       };
72041     } catch (Dali::DaliException e) {
72042       {
72043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72044       };
72045     } catch (...) {
72046       {
72047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72048       };
72049     }
72050   }
72051
72052   jresult = result;
72053   return jresult;
72054 }
72055
72056
72057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
72058   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72059   unsigned int arg2 ;
72060   Dali::Vector3 *arg3 = 0 ;
72061   Dali::Vector3 *arg4 = 0 ;
72062
72063   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72064   arg2 = (unsigned int)jarg2;
72065   arg3 = (Dali::Vector3 *)jarg3;
72066   if (!arg3) {
72067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72068     return ;
72069   }
72070   arg4 = (Dali::Vector3 *)jarg4;
72071   if (!arg4) {
72072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72073     return ;
72074   }
72075   {
72076     try {
72077       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
72078     } catch (std::out_of_range& e) {
72079       {
72080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72081       };
72082     } catch (std::exception& e) {
72083       {
72084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72085       };
72086     } catch (Dali::DaliException e) {
72087       {
72088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72089       };
72090     } catch (...) {
72091       {
72092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72093       };
72094     }
72095   }
72096
72097 }
72098
72099
72100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
72101   void * jresult ;
72102   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72103   Dali::Degree result;
72104
72105   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72106   {
72107     try {
72108       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
72109     } catch (std::out_of_range& e) {
72110       {
72111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72112       };
72113     } catch (std::exception& e) {
72114       {
72115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72116       };
72117     } catch (Dali::DaliException e) {
72118       {
72119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72120       };
72121     } catch (...) {
72122       {
72123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72124       };
72125     }
72126   }
72127
72128   jresult = new Dali::Degree((const Dali::Degree &)result);
72129   return jresult;
72130 }
72131
72132
72133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
72134   float jresult ;
72135   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72136   float result;
72137
72138   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72139   {
72140     try {
72141       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
72142     } catch (std::out_of_range& e) {
72143       {
72144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72145       };
72146     } catch (std::exception& e) {
72147       {
72148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72149       };
72150     } catch (Dali::DaliException e) {
72151       {
72152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72153       };
72154     } catch (...) {
72155       {
72156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72157       };
72158     }
72159   }
72160
72161   jresult = result;
72162   return jresult;
72163 }
72164
72165
72166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
72167   float jresult ;
72168   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72169   float result;
72170
72171   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72172   {
72173     try {
72174       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
72175     } catch (std::out_of_range& e) {
72176       {
72177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72178       };
72179     } catch (std::exception& e) {
72180       {
72181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72182       };
72183     } catch (Dali::DaliException e) {
72184       {
72185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72186       };
72187     } catch (...) {
72188       {
72189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72190       };
72191     }
72192   }
72193
72194   jresult = result;
72195   return jresult;
72196 }
72197
72198
72199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
72200   float jresult ;
72201   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72202   float result;
72203
72204   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72205   {
72206     try {
72207       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
72208     } catch (std::out_of_range& e) {
72209       {
72210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72211       };
72212     } catch (std::exception& e) {
72213       {
72214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72215       };
72216     } catch (Dali::DaliException e) {
72217       {
72218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72219       };
72220     } catch (...) {
72221       {
72222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72223       };
72224     }
72225   }
72226
72227   jresult = result;
72228   return jresult;
72229 }
72230
72231
72232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
72233   int jresult ;
72234   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72235   int arg2 ;
72236   int arg3 ;
72237   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
72238   bool arg5 ;
72239   int result;
72240
72241   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72242   arg2 = (int)jarg2;
72243   arg3 = (int)jarg3;
72244   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
72245   arg5 = jarg5 ? true : false;
72246   {
72247     try {
72248       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
72249     } catch (std::out_of_range& e) {
72250       {
72251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72252       };
72253     } catch (std::exception& e) {
72254       {
72255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72256       };
72257     } catch (Dali::DaliException e) {
72258       {
72259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72260       };
72261     } catch (...) {
72262       {
72263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72264       };
72265     }
72266   }
72267
72268   jresult = result;
72269   return jresult;
72270 }
72271
72272
72273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
72274   float jresult ;
72275   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72276   float result;
72277
72278   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72279   {
72280     try {
72281       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
72282     } catch (std::out_of_range& e) {
72283       {
72284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72285       };
72286     } catch (std::exception& e) {
72287       {
72288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72289       };
72290     } catch (Dali::DaliException e) {
72291       {
72292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72293       };
72294     } catch (...) {
72295       {
72296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72297       };
72298     }
72299   }
72300
72301   jresult = result;
72302   return jresult;
72303 }
72304
72305
72306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
72307   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72308   Dali::Actor *arg2 = 0 ;
72309   int arg3 ;
72310   Dali::Vector3 *arg4 = 0 ;
72311   Dali::Actor *arg5 = 0 ;
72312
72313   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72314   arg2 = (Dali::Actor *)jarg2;
72315   if (!arg2) {
72316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
72317     return ;
72318   }
72319   arg3 = (int)jarg3;
72320   arg4 = (Dali::Vector3 *)jarg4;
72321   if (!arg4) {
72322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72323     return ;
72324   }
72325   arg5 = (Dali::Actor *)jarg5;
72326   if (!arg5) {
72327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
72328     return ;
72329   }
72330   {
72331     try {
72332       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
72333     } catch (std::out_of_range& e) {
72334       {
72335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72336       };
72337     } catch (std::exception& e) {
72338       {
72339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72340       };
72341     } catch (Dali::DaliException e) {
72342       {
72343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72344       };
72345     } catch (...) {
72346       {
72347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72348       };
72349     }
72350   }
72351
72352 }
72353
72354
72355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
72356   void * jresult ;
72357   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72358   int arg2 ;
72359   float arg3 ;
72360   Dali::Vector3 *arg4 = 0 ;
72361   Dali::Vector3 result;
72362
72363   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72364   arg2 = (int)jarg2;
72365   arg3 = (float)jarg3;
72366   arg4 = (Dali::Vector3 *)jarg4;
72367   if (!arg4) {
72368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72369     return 0;
72370   }
72371   {
72372     try {
72373       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
72374     } catch (std::out_of_range& e) {
72375       {
72376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72377       };
72378     } catch (std::exception& e) {
72379       {
72380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72381       };
72382     } catch (Dali::DaliException e) {
72383       {
72384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72385       };
72386     } catch (...) {
72387       {
72388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72389       };
72390     }
72391   }
72392
72393   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72394   return jresult;
72395 }
72396
72397
72398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
72399   void * jresult ;
72400   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
72401   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
72402
72403   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
72404   {
72405     try {
72406       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
72407     } catch (std::out_of_range& e) {
72408       {
72409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72410       };
72411     } catch (std::exception& e) {
72412       {
72413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72414       };
72415     } catch (Dali::DaliException e) {
72416       {
72417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72418       };
72419     } catch (...) {
72420       {
72421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72422       };
72423     }
72424   }
72425
72426   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
72427   return jresult;
72428 }
72429
72430
72431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
72432   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
72433
72434   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
72435   {
72436     try {
72437       delete arg1;
72438     } catch (std::out_of_range& e) {
72439       {
72440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72441       };
72442     } catch (std::exception& e) {
72443       {
72444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72445       };
72446     } catch (Dali::DaliException e) {
72447       {
72448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72449       };
72450     } catch (...) {
72451       {
72452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72453       };
72454     }
72455   }
72456
72457 }
72458
72459
72460 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
72461   unsigned int jresult ;
72462   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
72463   unsigned int result;
72464
72465   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
72466   {
72467     try {
72468       result = (unsigned int)(arg1)->GetNumberOfItems();
72469     } catch (std::out_of_range& e) {
72470       {
72471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72472       };
72473     } catch (std::exception& e) {
72474       {
72475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72476       };
72477     } catch (Dali::DaliException e) {
72478       {
72479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72480       };
72481     } catch (...) {
72482       {
72483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72484       };
72485     }
72486   }
72487
72488   jresult = result;
72489   return jresult;
72490 }
72491
72492
72493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
72494   void * jresult ;
72495   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
72496   unsigned int arg2 ;
72497   Dali::Actor result;
72498
72499   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
72500   arg2 = (unsigned int)jarg2;
72501   {
72502     try {
72503       result = (arg1)->NewItem(arg2);
72504     } catch (std::out_of_range& e) {
72505       {
72506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72507       };
72508     } catch (std::exception& e) {
72509       {
72510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72511       };
72512     } catch (Dali::DaliException e) {
72513       {
72514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72515       };
72516     } catch (...) {
72517       {
72518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72519       };
72520     }
72521   }
72522
72523   jresult = new Dali::Actor((const Dali::Actor &)result);
72524   return jresult;
72525 }
72526
72527
72528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
72529   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
72530   unsigned int arg2 ;
72531   Dali::Actor arg3 ;
72532   Dali::Actor *argp3 ;
72533
72534   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
72535   arg2 = (unsigned int)jarg2;
72536   argp3 = (Dali::Actor *)jarg3;
72537   if (!argp3) {
72538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72539     return ;
72540   }
72541   arg3 = *argp3;
72542   {
72543     try {
72544       (arg1)->ItemReleased(arg2,arg3);
72545     } catch (std::out_of_range& e) {
72546       {
72547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72548       };
72549     } catch (std::exception& e) {
72550       {
72551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72552       };
72553     } catch (Dali::DaliException e) {
72554       {
72555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72556       };
72557     } catch (...) {
72558       {
72559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72560       };
72561     }
72562   }
72563
72564 }
72565
72566
72567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
72568   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
72569   unsigned int arg2 ;
72570   Dali::Actor arg3 ;
72571   Dali::Actor *argp3 ;
72572
72573   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
72574   arg2 = (unsigned int)jarg2;
72575   argp3 = (Dali::Actor *)jarg3;
72576   if (!argp3) {
72577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72578     return ;
72579   }
72580   arg3 = *argp3;
72581   {
72582     try {
72583       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
72584     } catch (std::out_of_range& e) {
72585       {
72586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72587       };
72588     } catch (std::exception& e) {
72589       {
72590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72591       };
72592     } catch (Dali::DaliException e) {
72593       {
72594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72595       };
72596     } catch (...) {
72597       {
72598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72599       };
72600     }
72601   }
72602
72603 }
72604
72605
72606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
72607   void * jresult ;
72608   Dali::Toolkit::ItemFactory *result = 0 ;
72609
72610   {
72611     try {
72612       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
72613     } catch (std::out_of_range& e) {
72614       {
72615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72616       };
72617     } catch (std::exception& e) {
72618       {
72619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72620       };
72621     } catch (Dali::DaliException e) {
72622       {
72623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72624       };
72625     } catch (...) {
72626       {
72627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72628       };
72629     }
72630   }
72631
72632   jresult = (void *)result;
72633   return jresult;
72634 }
72635
72636
72637 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) {
72638   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
72639   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
72640   if (director) {
72641     director->swig_connect_director(callback0, callback1, callback2);
72642   }
72643 }
72644
72645
72646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
72647   int jresult ;
72648   int result;
72649
72650   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
72651   jresult = (int)result;
72652   return jresult;
72653 }
72654
72655
72656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
72657   int jresult ;
72658   int result;
72659
72660   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
72661   jresult = (int)result;
72662   return jresult;
72663 }
72664
72665
72666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
72667   int jresult ;
72668   int result;
72669
72670   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
72671   jresult = (int)result;
72672   return jresult;
72673 }
72674
72675
72676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
72677   int jresult ;
72678   int result;
72679
72680   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
72681   jresult = (int)result;
72682   return jresult;
72683 }
72684
72685
72686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
72687   int jresult ;
72688   int result;
72689
72690   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
72691   jresult = (int)result;
72692   return jresult;
72693 }
72694
72695
72696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
72697   int jresult ;
72698   int result;
72699
72700   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
72701   jresult = (int)result;
72702   return jresult;
72703 }
72704
72705
72706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
72707   int jresult ;
72708   int result;
72709
72710   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
72711   jresult = (int)result;
72712   return jresult;
72713 }
72714
72715
72716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
72717   int jresult ;
72718   int result;
72719
72720   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
72721   jresult = (int)result;
72722   return jresult;
72723 }
72724
72725
72726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
72727   int jresult ;
72728   int result;
72729
72730   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
72731   jresult = (int)result;
72732   return jresult;
72733 }
72734
72735
72736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
72737   int jresult ;
72738   int result;
72739
72740   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
72741   jresult = (int)result;
72742   return jresult;
72743 }
72744
72745
72746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
72747   int jresult ;
72748   int result;
72749
72750   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
72751   jresult = (int)result;
72752   return jresult;
72753 }
72754
72755
72756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
72757   void * jresult ;
72758   Dali::Toolkit::ItemView::Property *result = 0 ;
72759
72760   {
72761     try {
72762       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
72763     } catch (std::out_of_range& e) {
72764       {
72765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72766       };
72767     } catch (std::exception& e) {
72768       {
72769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72770       };
72771     } catch (Dali::DaliException e) {
72772       {
72773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72774       };
72775     } catch (...) {
72776       {
72777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72778       };
72779     }
72780   }
72781
72782   jresult = (void *)result;
72783   return jresult;
72784 }
72785
72786
72787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
72788   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
72789
72790   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
72791   {
72792     try {
72793       delete arg1;
72794     } catch (std::out_of_range& e) {
72795       {
72796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72797       };
72798     } catch (std::exception& e) {
72799       {
72800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72801       };
72802     } catch (Dali::DaliException e) {
72803       {
72804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72805       };
72806     } catch (...) {
72807       {
72808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72809       };
72810     }
72811   }
72812
72813 }
72814
72815
72816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
72817   void * jresult ;
72818   Dali::Toolkit::ItemView *result = 0 ;
72819
72820   {
72821     try {
72822       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
72823     } catch (std::out_of_range& e) {
72824       {
72825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72826       };
72827     } catch (std::exception& e) {
72828       {
72829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72830       };
72831     } catch (Dali::DaliException e) {
72832       {
72833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72834       };
72835     } catch (...) {
72836       {
72837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72838       };
72839     }
72840   }
72841
72842   jresult = (void *)result;
72843   return jresult;
72844 }
72845
72846
72847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
72848   void * jresult ;
72849   Dali::Toolkit::ItemView *arg1 = 0 ;
72850   Dali::Toolkit::ItemView *result = 0 ;
72851
72852   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72853   if (!arg1) {
72854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
72855     return 0;
72856   }
72857   {
72858     try {
72859       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
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 = (void *)result;
72880   return jresult;
72881 }
72882
72883
72884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
72885   void * jresult ;
72886   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72887   Dali::Toolkit::ItemView *arg2 = 0 ;
72888   Dali::Toolkit::ItemView *result = 0 ;
72889
72890   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72891   arg2 = (Dali::Toolkit::ItemView *)jarg2;
72892   if (!arg2) {
72893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
72894     return 0;
72895   }
72896   {
72897     try {
72898       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
72899     } catch (std::out_of_range& e) {
72900       {
72901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72902       };
72903     } catch (std::exception& e) {
72904       {
72905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72906       };
72907     } catch (Dali::DaliException e) {
72908       {
72909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72910       };
72911     } catch (...) {
72912       {
72913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72914       };
72915     }
72916   }
72917
72918   jresult = (void *)result;
72919   return jresult;
72920 }
72921
72922
72923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
72924   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72925
72926   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72927   {
72928     try {
72929       delete arg1;
72930     } catch (std::out_of_range& e) {
72931       {
72932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72933       };
72934     } catch (std::exception& e) {
72935       {
72936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72937       };
72938     } catch (Dali::DaliException e) {
72939       {
72940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72941       };
72942     } catch (...) {
72943       {
72944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72945       };
72946     }
72947   }
72948
72949 }
72950
72951
72952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
72953   void * jresult ;
72954   Dali::Toolkit::ItemFactory *arg1 = 0 ;
72955   Dali::Toolkit::ItemView result;
72956
72957   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
72958   if (!arg1) {
72959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
72960     return 0;
72961   }
72962   {
72963     try {
72964       result = Dali::Toolkit::ItemView::New(*arg1);
72965     } catch (std::out_of_range& e) {
72966       {
72967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72968       };
72969     } catch (std::exception& e) {
72970       {
72971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72972       };
72973     } catch (Dali::DaliException e) {
72974       {
72975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72976       };
72977     } catch (...) {
72978       {
72979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72980       };
72981     }
72982   }
72983
72984   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
72985   return jresult;
72986 }
72987
72988
72989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
72990   void * jresult ;
72991   Dali::BaseHandle arg1 ;
72992   Dali::BaseHandle *argp1 ;
72993   Dali::Toolkit::ItemView result;
72994
72995   argp1 = (Dali::BaseHandle *)jarg1;
72996   if (!argp1) {
72997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72998     return 0;
72999   }
73000   arg1 = *argp1;
73001   {
73002     try {
73003       result = Dali::Toolkit::ItemView::DownCast(arg1);
73004     } catch (std::out_of_range& e) {
73005       {
73006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73007       };
73008     } catch (std::exception& e) {
73009       {
73010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73011       };
73012     } catch (Dali::DaliException e) {
73013       {
73014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73015       };
73016     } catch (...) {
73017       {
73018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73019       };
73020     }
73021   }
73022
73023   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
73024   return jresult;
73025 }
73026
73027
73028 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
73029   unsigned int jresult ;
73030   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73031   unsigned int result;
73032
73033   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73034   {
73035     try {
73036       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
73037     } catch (std::out_of_range& e) {
73038       {
73039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73040       };
73041     } catch (std::exception& e) {
73042       {
73043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73044       };
73045     } catch (Dali::DaliException e) {
73046       {
73047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73048       };
73049     } catch (...) {
73050       {
73051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73052       };
73053     }
73054   }
73055
73056   jresult = result;
73057   return jresult;
73058 }
73059
73060
73061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
73062   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73063   Dali::Toolkit::ItemLayout *arg2 = 0 ;
73064
73065   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73066   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
73067   if (!arg2) {
73068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
73069     return ;
73070   }
73071   {
73072     try {
73073       (arg1)->AddLayout(*arg2);
73074     } catch (std::out_of_range& e) {
73075       {
73076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73077       };
73078     } catch (std::exception& e) {
73079       {
73080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73081       };
73082     } catch (Dali::DaliException e) {
73083       {
73084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73085       };
73086     } catch (...) {
73087       {
73088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73089       };
73090     }
73091   }
73092
73093 }
73094
73095
73096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
73097   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73098   unsigned int arg2 ;
73099
73100   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73101   arg2 = (unsigned int)jarg2;
73102   {
73103     try {
73104       (arg1)->RemoveLayout(arg2);
73105     } catch (std::out_of_range& e) {
73106       {
73107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73108       };
73109     } catch (std::exception& e) {
73110       {
73111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73112       };
73113     } catch (Dali::DaliException e) {
73114       {
73115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73116       };
73117     } catch (...) {
73118       {
73119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73120       };
73121     }
73122   }
73123
73124 }
73125
73126
73127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
73128   void * jresult ;
73129   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73130   unsigned int arg2 ;
73131   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
73132
73133   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73134   arg2 = (unsigned int)jarg2;
73135   {
73136     try {
73137       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
73138     } catch (std::out_of_range& e) {
73139       {
73140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73141       };
73142     } catch (std::exception& e) {
73143       {
73144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73145       };
73146     } catch (Dali::DaliException e) {
73147       {
73148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73149       };
73150     } catch (...) {
73151       {
73152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73153       };
73154     }
73155   }
73156
73157   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
73158   return jresult;
73159 }
73160
73161
73162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
73163   void * jresult ;
73164   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73165   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
73166
73167   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73168   {
73169     try {
73170       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
73171     } catch (std::out_of_range& e) {
73172       {
73173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73174       };
73175     } catch (std::exception& e) {
73176       {
73177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73178       };
73179     } catch (Dali::DaliException e) {
73180       {
73181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73182       };
73183     } catch (...) {
73184       {
73185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73186       };
73187     }
73188   }
73189
73190   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
73191   return jresult;
73192 }
73193
73194
73195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
73196   float jresult ;
73197   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73198   Dali::Toolkit::ItemId arg2 ;
73199   float result;
73200
73201   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73202   arg2 = (Dali::Toolkit::ItemId)jarg2;
73203   {
73204     try {
73205       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
73206     } catch (std::out_of_range& e) {
73207       {
73208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73209       };
73210     } catch (std::exception& e) {
73211       {
73212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73213       };
73214     } catch (Dali::DaliException e) {
73215       {
73216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73217       };
73218     } catch (...) {
73219       {
73220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73221       };
73222     }
73223   }
73224
73225   jresult = result;
73226   return jresult;
73227 }
73228
73229
73230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
73231   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73232   unsigned int arg2 ;
73233   Dali::Vector3 arg3 ;
73234   float arg4 ;
73235   Dali::Vector3 *argp3 ;
73236
73237   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73238   arg2 = (unsigned int)jarg2;
73239   argp3 = (Dali::Vector3 *)jarg3;
73240   if (!argp3) {
73241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73242     return ;
73243   }
73244   arg3 = *argp3;
73245   arg4 = (float)jarg4;
73246   {
73247     try {
73248       (arg1)->ActivateLayout(arg2,arg3,arg4);
73249     } catch (std::out_of_range& e) {
73250       {
73251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73252       };
73253     } catch (std::exception& e) {
73254       {
73255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73256       };
73257     } catch (Dali::DaliException e) {
73258       {
73259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73260       };
73261     } catch (...) {
73262       {
73263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73264       };
73265     }
73266   }
73267
73268 }
73269
73270
73271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
73272   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73273
73274   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73275   {
73276     try {
73277       (arg1)->DeactivateCurrentLayout();
73278     } catch (std::out_of_range& e) {
73279       {
73280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73281       };
73282     } catch (std::exception& e) {
73283       {
73284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73285       };
73286     } catch (Dali::DaliException e) {
73287       {
73288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73289       };
73290     } catch (...) {
73291       {
73292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73293       };
73294     }
73295   }
73296
73297 }
73298
73299
73300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
73301   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73302   float arg2 ;
73303
73304   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73305   arg2 = (float)jarg2;
73306   {
73307     try {
73308       (arg1)->SetMinimumSwipeSpeed(arg2);
73309     } catch (std::out_of_range& e) {
73310       {
73311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73312       };
73313     } catch (std::exception& e) {
73314       {
73315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73316       };
73317     } catch (Dali::DaliException e) {
73318       {
73319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73320       };
73321     } catch (...) {
73322       {
73323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73324       };
73325     }
73326   }
73327
73328 }
73329
73330
73331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
73332   float jresult ;
73333   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73334   float result;
73335
73336   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73337   {
73338     try {
73339       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
73340     } catch (std::out_of_range& e) {
73341       {
73342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73343       };
73344     } catch (std::exception& e) {
73345       {
73346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73347       };
73348     } catch (Dali::DaliException e) {
73349       {
73350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73351       };
73352     } catch (...) {
73353       {
73354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73355       };
73356     }
73357   }
73358
73359   jresult = result;
73360   return jresult;
73361 }
73362
73363
73364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
73365   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73366   float arg2 ;
73367
73368   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73369   arg2 = (float)jarg2;
73370   {
73371     try {
73372       (arg1)->SetMinimumSwipeDistance(arg2);
73373     } catch (std::out_of_range& e) {
73374       {
73375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73376       };
73377     } catch (std::exception& e) {
73378       {
73379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73380       };
73381     } catch (Dali::DaliException e) {
73382       {
73383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73384       };
73385     } catch (...) {
73386       {
73387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73388       };
73389     }
73390   }
73391
73392 }
73393
73394
73395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
73396   float jresult ;
73397   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73398   float result;
73399
73400   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73401   {
73402     try {
73403       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
73404     } catch (std::out_of_range& e) {
73405       {
73406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73407       };
73408     } catch (std::exception& e) {
73409       {
73410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73411       };
73412     } catch (Dali::DaliException e) {
73413       {
73414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73415       };
73416     } catch (...) {
73417       {
73418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73419       };
73420     }
73421   }
73422
73423   jresult = result;
73424   return jresult;
73425 }
73426
73427
73428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
73429   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73430   float arg2 ;
73431
73432   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73433   arg2 = (float)jarg2;
73434   {
73435     try {
73436       (arg1)->SetWheelScrollDistanceStep(arg2);
73437     } catch (std::out_of_range& e) {
73438       {
73439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73440       };
73441     } catch (std::exception& e) {
73442       {
73443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73444       };
73445     } catch (Dali::DaliException e) {
73446       {
73447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73448       };
73449     } catch (...) {
73450       {
73451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73452       };
73453     }
73454   }
73455
73456 }
73457
73458
73459 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
73460   float jresult ;
73461   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73462   float result;
73463
73464   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73465   {
73466     try {
73467       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
73468     } catch (std::out_of_range& e) {
73469       {
73470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73471       };
73472     } catch (std::exception& e) {
73473       {
73474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73475       };
73476     } catch (Dali::DaliException e) {
73477       {
73478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73479       };
73480     } catch (...) {
73481       {
73482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73483       };
73484     }
73485   }
73486
73487   jresult = result;
73488   return jresult;
73489 }
73490
73491
73492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
73493   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73494   bool arg2 ;
73495
73496   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73497   arg2 = jarg2 ? true : false;
73498   {
73499     try {
73500       (arg1)->SetAnchoring(arg2);
73501     } catch (std::out_of_range& e) {
73502       {
73503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73504       };
73505     } catch (std::exception& e) {
73506       {
73507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73508       };
73509     } catch (Dali::DaliException e) {
73510       {
73511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73512       };
73513     } catch (...) {
73514       {
73515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73516       };
73517     }
73518   }
73519
73520 }
73521
73522 //// ========================= end of part 3 =============================
73523
73524 //// ========================== start part 4 ===============================
73525
73526
73527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
73528   unsigned int jresult ;
73529   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73530   bool result;
73531
73532   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73533   {
73534     try {
73535       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
73536     } catch (std::out_of_range& e) {
73537       {
73538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73539       };
73540     } catch (std::exception& e) {
73541       {
73542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73543       };
73544     } catch (Dali::DaliException e) {
73545       {
73546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73547       };
73548     } catch (...) {
73549       {
73550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73551       };
73552     }
73553   }
73554
73555   jresult = result;
73556   return jresult;
73557 }
73558
73559
73560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
73561   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73562   float arg2 ;
73563
73564   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73565   arg2 = (float)jarg2;
73566   {
73567     try {
73568       (arg1)->SetAnchoringDuration(arg2);
73569     } catch (std::out_of_range& e) {
73570       {
73571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73572       };
73573     } catch (std::exception& e) {
73574       {
73575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73576       };
73577     } catch (Dali::DaliException e) {
73578       {
73579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73580       };
73581     } catch (...) {
73582       {
73583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73584       };
73585     }
73586   }
73587
73588 }
73589
73590
73591 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
73592   float jresult ;
73593   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73594   float result;
73595
73596   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73597   {
73598     try {
73599       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
73600     } catch (std::out_of_range& e) {
73601       {
73602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73603       };
73604     } catch (std::exception& e) {
73605       {
73606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73607       };
73608     } catch (Dali::DaliException e) {
73609       {
73610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73611       };
73612     } catch (...) {
73613       {
73614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73615       };
73616     }
73617   }
73618
73619   jresult = result;
73620   return jresult;
73621 }
73622
73623
73624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
73625   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73626   Dali::Toolkit::ItemId arg2 ;
73627   float arg3 ;
73628
73629   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73630   arg2 = (Dali::Toolkit::ItemId)jarg2;
73631   arg3 = (float)jarg3;
73632   {
73633     try {
73634       (arg1)->ScrollToItem(arg2,arg3);
73635     } catch (std::out_of_range& e) {
73636       {
73637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73638       };
73639     } catch (std::exception& e) {
73640       {
73641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73642       };
73643     } catch (Dali::DaliException e) {
73644       {
73645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73646       };
73647     } catch (...) {
73648       {
73649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73650       };
73651     }
73652   }
73653
73654 }
73655
73656
73657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
73658   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73659   float arg2 ;
73660
73661   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73662   arg2 = (float)jarg2;
73663   {
73664     try {
73665       (arg1)->SetRefreshInterval(arg2);
73666     } catch (std::out_of_range& e) {
73667       {
73668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73669       };
73670     } catch (std::exception& e) {
73671       {
73672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73673       };
73674     } catch (Dali::DaliException e) {
73675       {
73676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73677       };
73678     } catch (...) {
73679       {
73680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73681       };
73682     }
73683   }
73684
73685 }
73686
73687
73688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
73689   float jresult ;
73690   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73691   float result;
73692
73693   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73694   {
73695     try {
73696       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
73697     } catch (std::out_of_range& e) {
73698       {
73699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73700       };
73701     } catch (std::exception& e) {
73702       {
73703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73704       };
73705     } catch (Dali::DaliException e) {
73706       {
73707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73708       };
73709     } catch (...) {
73710       {
73711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73712       };
73713     }
73714   }
73715
73716   jresult = result;
73717   return jresult;
73718 }
73719
73720
73721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
73722   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73723
73724   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73725   {
73726     try {
73727       (arg1)->Refresh();
73728     } catch (std::out_of_range& e) {
73729       {
73730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73731       };
73732     } catch (std::exception& e) {
73733       {
73734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73735       };
73736     } catch (Dali::DaliException e) {
73737       {
73738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73739       };
73740     } catch (...) {
73741       {
73742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73743       };
73744     }
73745   }
73746
73747 }
73748
73749
73750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
73751   void * jresult ;
73752   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73753   Dali::Toolkit::ItemId arg2 ;
73754   Dali::Actor result;
73755
73756   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73757   arg2 = (Dali::Toolkit::ItemId)jarg2;
73758   {
73759     try {
73760       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
73761     } catch (std::out_of_range& e) {
73762       {
73763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73764       };
73765     } catch (std::exception& e) {
73766       {
73767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73768       };
73769     } catch (Dali::DaliException e) {
73770       {
73771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73772       };
73773     } catch (...) {
73774       {
73775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73776       };
73777     }
73778   }
73779
73780   jresult = new Dali::Actor((const Dali::Actor &)result);
73781   return jresult;
73782 }
73783
73784
73785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
73786   unsigned int jresult ;
73787   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73788   Dali::Actor arg2 ;
73789   Dali::Actor *argp2 ;
73790   Dali::Toolkit::ItemId result;
73791
73792   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73793   argp2 = (Dali::Actor *)jarg2;
73794   if (!argp2) {
73795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73796     return 0;
73797   }
73798   arg2 = *argp2;
73799   {
73800     try {
73801       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
73802     } catch (std::out_of_range& e) {
73803       {
73804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73805       };
73806     } catch (std::exception& e) {
73807       {
73808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73809       };
73810     } catch (Dali::DaliException e) {
73811       {
73812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73813       };
73814     } catch (...) {
73815       {
73816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73817       };
73818     }
73819   }
73820
73821   jresult = result;
73822   return jresult;
73823 }
73824
73825
73826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
73827   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73828   Dali::Toolkit::Item arg2 ;
73829   float arg3 ;
73830   Dali::Toolkit::Item *argp2 ;
73831
73832   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73833   argp2 = (Dali::Toolkit::Item *)jarg2;
73834   if (!argp2) {
73835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
73836     return ;
73837   }
73838   arg2 = *argp2;
73839   arg3 = (float)jarg3;
73840   {
73841     try {
73842       (arg1)->InsertItem(arg2,arg3);
73843     } catch (std::out_of_range& e) {
73844       {
73845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73846       };
73847     } catch (std::exception& e) {
73848       {
73849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73850       };
73851     } catch (Dali::DaliException e) {
73852       {
73853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73854       };
73855     } catch (...) {
73856       {
73857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73858       };
73859     }
73860   }
73861
73862 }
73863
73864
73865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
73866   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73867   Dali::Toolkit::ItemContainer *arg2 = 0 ;
73868   float arg3 ;
73869
73870   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73871   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
73872   if (!arg2) {
73873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
73874     return ;
73875   }
73876   arg3 = (float)jarg3;
73877   {
73878     try {
73879       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
73880     } catch (std::out_of_range& e) {
73881       {
73882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73883       };
73884     } catch (std::exception& e) {
73885       {
73886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73887       };
73888     } catch (Dali::DaliException e) {
73889       {
73890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73891       };
73892     } catch (...) {
73893       {
73894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73895       };
73896     }
73897   }
73898
73899 }
73900
73901
73902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
73903   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73904   Dali::Toolkit::ItemId arg2 ;
73905   float arg3 ;
73906
73907   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73908   arg2 = (Dali::Toolkit::ItemId)jarg2;
73909   arg3 = (float)jarg3;
73910   {
73911     try {
73912       (arg1)->RemoveItem(arg2,arg3);
73913     } catch (std::out_of_range& e) {
73914       {
73915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73916       };
73917     } catch (std::exception& e) {
73918       {
73919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73920       };
73921     } catch (Dali::DaliException e) {
73922       {
73923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73924       };
73925     } catch (...) {
73926       {
73927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73928       };
73929     }
73930   }
73931
73932 }
73933
73934
73935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
73936   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73937   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
73938   float arg3 ;
73939
73940   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73941   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
73942   if (!arg2) {
73943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
73944     return ;
73945   }
73946   arg3 = (float)jarg3;
73947   {
73948     try {
73949       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
73950     } catch (std::out_of_range& e) {
73951       {
73952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73953       };
73954     } catch (std::exception& e) {
73955       {
73956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73957       };
73958     } catch (Dali::DaliException e) {
73959       {
73960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73961       };
73962     } catch (...) {
73963       {
73964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73965       };
73966     }
73967   }
73968
73969 }
73970
73971
73972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
73973   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73974   Dali::Toolkit::Item arg2 ;
73975   float arg3 ;
73976   Dali::Toolkit::Item *argp2 ;
73977
73978   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73979   argp2 = (Dali::Toolkit::Item *)jarg2;
73980   if (!argp2) {
73981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
73982     return ;
73983   }
73984   arg2 = *argp2;
73985   arg3 = (float)jarg3;
73986   {
73987     try {
73988       (arg1)->ReplaceItem(arg2,arg3);
73989     } catch (std::out_of_range& e) {
73990       {
73991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73992       };
73993     } catch (std::exception& e) {
73994       {
73995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73996       };
73997     } catch (Dali::DaliException e) {
73998       {
73999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74000       };
74001     } catch (...) {
74002       {
74003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74004       };
74005     }
74006   }
74007
74008 }
74009
74010
74011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
74012   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74013   Dali::Toolkit::ItemContainer *arg2 = 0 ;
74014   float arg3 ;
74015
74016   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74017   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
74018   if (!arg2) {
74019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
74020     return ;
74021   }
74022   arg3 = (float)jarg3;
74023   {
74024     try {
74025       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
74026     } catch (std::out_of_range& e) {
74027       {
74028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74029       };
74030     } catch (std::exception& e) {
74031       {
74032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74033       };
74034     } catch (Dali::DaliException e) {
74035       {
74036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74037       };
74038     } catch (...) {
74039       {
74040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74041       };
74042     }
74043   }
74044
74045 }
74046
74047
74048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
74049   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74050   Dali::Vector3 *arg2 = 0 ;
74051
74052   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74053   arg2 = (Dali::Vector3 *)jarg2;
74054   if (!arg2) {
74055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74056     return ;
74057   }
74058   {
74059     try {
74060       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
74061     } catch (std::out_of_range& e) {
74062       {
74063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74064       };
74065     } catch (std::exception& e) {
74066       {
74067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74068       };
74069     } catch (Dali::DaliException e) {
74070       {
74071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74072       };
74073     } catch (...) {
74074       {
74075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74076       };
74077     }
74078   }
74079
74080 }
74081
74082
74083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
74084   void * jresult ;
74085   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74086   Dali::Vector3 result;
74087
74088   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74089   {
74090     try {
74091       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
74092     } catch (std::out_of_range& e) {
74093       {
74094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74095       };
74096     } catch (std::exception& e) {
74097       {
74098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74099       };
74100     } catch (Dali::DaliException e) {
74101       {
74102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74103       };
74104     } catch (...) {
74105       {
74106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74107       };
74108     }
74109   }
74110
74111   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74112   return jresult;
74113 }
74114
74115
74116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
74117   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74118   Dali::Vector3 *arg2 = 0 ;
74119
74120   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74121   arg2 = (Dali::Vector3 *)jarg2;
74122   if (!arg2) {
74123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74124     return ;
74125   }
74126   {
74127     try {
74128       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
74129     } catch (std::out_of_range& e) {
74130       {
74131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74132       };
74133     } catch (std::exception& e) {
74134       {
74135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74136       };
74137     } catch (Dali::DaliException e) {
74138       {
74139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74140       };
74141     } catch (...) {
74142       {
74143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74144       };
74145     }
74146   }
74147
74148 }
74149
74150
74151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
74152   void * jresult ;
74153   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74154   Dali::Vector3 result;
74155
74156   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74157   {
74158     try {
74159       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
74160     } catch (std::out_of_range& e) {
74161       {
74162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74163       };
74164     } catch (std::exception& e) {
74165       {
74166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74167       };
74168     } catch (Dali::DaliException e) {
74169       {
74170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74171       };
74172     } catch (...) {
74173       {
74174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74175       };
74176     }
74177   }
74178
74179   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74180   return jresult;
74181 }
74182
74183
74184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
74185   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74186   Dali::Toolkit::ItemRange *arg2 = 0 ;
74187
74188   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74189   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74190   if (!arg2) {
74191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
74192     return ;
74193   }
74194   {
74195     try {
74196       (arg1)->GetItemsRange(*arg2);
74197     } catch (std::out_of_range& e) {
74198       {
74199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74200       };
74201     } catch (std::exception& e) {
74202       {
74203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74204       };
74205     } catch (Dali::DaliException e) {
74206       {
74207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74208       };
74209     } catch (...) {
74210       {
74211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74212       };
74213     }
74214   }
74215
74216 }
74217
74218
74219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
74220   void * jresult ;
74221   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74222   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
74223
74224   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74225   {
74226     try {
74227       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
74228     } catch (std::out_of_range& e) {
74229       {
74230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74231       };
74232     } catch (std::exception& e) {
74233       {
74234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74235       };
74236     } catch (Dali::DaliException e) {
74237       {
74238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74239       };
74240     } catch (...) {
74241       {
74242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74243       };
74244     }
74245   }
74246
74247   jresult = (void *)result;
74248   return jresult;
74249 }
74250
74251
74252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
74253   Dali::Vector3 *arg1 = 0 ;
74254   PropertyInputContainer *arg2 = 0 ;
74255
74256   arg1 = (Dali::Vector3 *)jarg1;
74257   if (!arg1) {
74258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74259     return ;
74260   }
74261   arg2 = (PropertyInputContainer *)jarg2;
74262   if (!arg2) {
74263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
74264     return ;
74265   }
74266   {
74267     try {
74268       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
74269     } catch (std::out_of_range& e) {
74270       {
74271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74272       };
74273     } catch (std::exception& e) {
74274       {
74275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74276       };
74277     } catch (Dali::DaliException e) {
74278       {
74279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74280       };
74281     } catch (...) {
74282       {
74283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74284       };
74285     }
74286   }
74287
74288 }
74289
74290
74291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
74292   Dali::Vector3 *arg1 = 0 ;
74293   PropertyInputContainer *arg2 = 0 ;
74294
74295   arg1 = (Dali::Vector3 *)jarg1;
74296   if (!arg1) {
74297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74298     return ;
74299   }
74300   arg2 = (PropertyInputContainer *)jarg2;
74301   if (!arg2) {
74302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
74303     return ;
74304   }
74305   {
74306     try {
74307       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
74308     } catch (std::out_of_range& e) {
74309       {
74310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74311       };
74312     } catch (std::exception& e) {
74313       {
74314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74315       };
74316     } catch (Dali::DaliException e) {
74317       {
74318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74319       };
74320     } catch (...) {
74321       {
74322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74323       };
74324     }
74325   }
74326
74327 }
74328
74329
74330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
74331   void * jresult ;
74332   Dali::Toolkit::ScrollViewEffect *result = 0 ;
74333
74334   {
74335     try {
74336       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
74337     } catch (std::out_of_range& e) {
74338       {
74339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74340       };
74341     } catch (std::exception& e) {
74342       {
74343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74344       };
74345     } catch (Dali::DaliException e) {
74346       {
74347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74348       };
74349     } catch (...) {
74350       {
74351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74352       };
74353     }
74354   }
74355
74356   jresult = (void *)result;
74357   return jresult;
74358 }
74359
74360
74361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
74362   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
74363
74364   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
74365   {
74366     try {
74367       delete arg1;
74368     } catch (std::out_of_range& e) {
74369       {
74370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74371       };
74372     } catch (std::exception& e) {
74373       {
74374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74375       };
74376     } catch (Dali::DaliException e) {
74377       {
74378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74379       };
74380     } catch (...) {
74381       {
74382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74383       };
74384     }
74385   }
74386
74387 }
74388
74389
74390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
74391   void * jresult ;
74392   Dali::Path arg1 ;
74393   Dali::Vector3 *arg2 = 0 ;
74394   Dali::Property::Index arg3 ;
74395   Dali::Vector3 *arg4 = 0 ;
74396   unsigned int arg5 ;
74397   Dali::Path *argp1 ;
74398   Dali::Toolkit::ScrollViewPagePathEffect result;
74399
74400   argp1 = (Dali::Path *)jarg1;
74401   if (!argp1) {
74402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
74403     return 0;
74404   }
74405   arg1 = *argp1;
74406   arg2 = (Dali::Vector3 *)jarg2;
74407   if (!arg2) {
74408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74409     return 0;
74410   }
74411   arg3 = (Dali::Property::Index)jarg3;
74412   arg4 = (Dali::Vector3 *)jarg4;
74413   if (!arg4) {
74414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74415     return 0;
74416   }
74417   arg5 = (unsigned int)jarg5;
74418   {
74419     try {
74420       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
74421     } catch (std::out_of_range& e) {
74422       {
74423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74424       };
74425     } catch (std::exception& e) {
74426       {
74427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74428       };
74429     } catch (Dali::DaliException e) {
74430       {
74431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74432       };
74433     } catch (...) {
74434       {
74435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74436       };
74437     }
74438   }
74439
74440   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
74441   return jresult;
74442 }
74443
74444
74445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
74446   void * jresult ;
74447   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
74448
74449   {
74450     try {
74451       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
74452     } catch (std::out_of_range& e) {
74453       {
74454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74455       };
74456     } catch (std::exception& e) {
74457       {
74458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74459       };
74460     } catch (Dali::DaliException e) {
74461       {
74462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74463       };
74464     } catch (...) {
74465       {
74466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74467       };
74468     }
74469   }
74470
74471   jresult = (void *)result;
74472   return jresult;
74473 }
74474
74475
74476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
74477   void * jresult ;
74478   Dali::BaseHandle arg1 ;
74479   Dali::BaseHandle *argp1 ;
74480   Dali::Toolkit::ScrollViewPagePathEffect result;
74481
74482   argp1 = (Dali::BaseHandle *)jarg1;
74483   if (!argp1) {
74484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74485     return 0;
74486   }
74487   arg1 = *argp1;
74488   {
74489     try {
74490       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
74491     } catch (std::out_of_range& e) {
74492       {
74493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74494       };
74495     } catch (std::exception& e) {
74496       {
74497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74498       };
74499     } catch (Dali::DaliException e) {
74500       {
74501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74502       };
74503     } catch (...) {
74504       {
74505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74506       };
74507     }
74508   }
74509
74510   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
74511   return jresult;
74512 }
74513
74514
74515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
74516   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
74517   Dali::Actor arg2 ;
74518   unsigned int arg3 ;
74519   Dali::Actor *argp2 ;
74520
74521   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
74522   argp2 = (Dali::Actor *)jarg2;
74523   if (!argp2) {
74524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74525     return ;
74526   }
74527   arg2 = *argp2;
74528   arg3 = (unsigned int)jarg3;
74529   {
74530     try {
74531       (arg1)->ApplyToPage(arg2,arg3);
74532     } catch (std::out_of_range& e) {
74533       {
74534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74535       };
74536     } catch (std::exception& e) {
74537       {
74538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74539       };
74540     } catch (Dali::DaliException e) {
74541       {
74542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74543       };
74544     } catch (...) {
74545       {
74546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74547       };
74548     }
74549   }
74550
74551 }
74552
74553
74554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
74555   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
74556
74557   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
74558   {
74559     try {
74560       delete arg1;
74561     } catch (std::out_of_range& e) {
74562       {
74563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74564       };
74565     } catch (std::exception& e) {
74566       {
74567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74568       };
74569     } catch (Dali::DaliException e) {
74570       {
74571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74572       };
74573     } catch (...) {
74574       {
74575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74576       };
74577     }
74578   }
74579
74580 }
74581
74582
74583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
74584   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
74585   Dali::Toolkit::ClampState arg2 ;
74586
74587   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
74588   arg2 = (Dali::Toolkit::ClampState)jarg2;
74589   if (arg1) (arg1)->x = arg2;
74590 }
74591
74592
74593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
74594   int jresult ;
74595   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
74596   Dali::Toolkit::ClampState result;
74597
74598   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
74599   result = (Dali::Toolkit::ClampState) ((arg1)->x);
74600   jresult = (int)result;
74601   return jresult;
74602 }
74603
74604
74605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
74606   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
74607   Dali::Toolkit::ClampState arg2 ;
74608
74609   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
74610   arg2 = (Dali::Toolkit::ClampState)jarg2;
74611   if (arg1) (arg1)->y = arg2;
74612 }
74613
74614
74615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
74616   int jresult ;
74617   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
74618   Dali::Toolkit::ClampState result;
74619
74620   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
74621   result = (Dali::Toolkit::ClampState) ((arg1)->y);
74622   jresult = (int)result;
74623   return jresult;
74624 }
74625
74626
74627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
74628   void * jresult ;
74629   Dali::Toolkit::ClampState2D *result = 0 ;
74630
74631   {
74632     try {
74633       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
74634     } catch (std::out_of_range& e) {
74635       {
74636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74637       };
74638     } catch (std::exception& e) {
74639       {
74640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74641       };
74642     } catch (Dali::DaliException e) {
74643       {
74644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74645       };
74646     } catch (...) {
74647       {
74648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74649       };
74650     }
74651   }
74652
74653   jresult = (void *)result;
74654   return jresult;
74655 }
74656
74657
74658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
74659   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
74660
74661   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
74662   {
74663     try {
74664       delete arg1;
74665     } catch (std::out_of_range& e) {
74666       {
74667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74668       };
74669     } catch (std::exception& e) {
74670       {
74671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74672       };
74673     } catch (Dali::DaliException e) {
74674       {
74675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74676       };
74677     } catch (...) {
74678       {
74679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74680       };
74681     }
74682   }
74683
74684 }
74685
74686
74687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
74688   void * jresult ;
74689   float arg1 ;
74690   float arg2 ;
74691   bool arg3 ;
74692   Dali::Toolkit::RulerDomain *result = 0 ;
74693
74694   arg1 = (float)jarg1;
74695   arg2 = (float)jarg2;
74696   arg3 = jarg3 ? true : false;
74697   {
74698     try {
74699       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
74700     } catch (std::out_of_range& e) {
74701       {
74702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74703       };
74704     } catch (std::exception& e) {
74705       {
74706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74707       };
74708     } catch (Dali::DaliException e) {
74709       {
74710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74711       };
74712     } catch (...) {
74713       {
74714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74715       };
74716     }
74717   }
74718
74719   jresult = (void *)result;
74720   return jresult;
74721 }
74722
74723
74724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
74725   void * jresult ;
74726   float arg1 ;
74727   float arg2 ;
74728   Dali::Toolkit::RulerDomain *result = 0 ;
74729
74730   arg1 = (float)jarg1;
74731   arg2 = (float)jarg2;
74732   {
74733     try {
74734       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
74735     } catch (std::out_of_range& e) {
74736       {
74737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74738       };
74739     } catch (std::exception& e) {
74740       {
74741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74742       };
74743     } catch (Dali::DaliException e) {
74744       {
74745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74746       };
74747     } catch (...) {
74748       {
74749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74750       };
74751     }
74752   }
74753
74754   jresult = (void *)result;
74755   return jresult;
74756 }
74757
74758
74759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
74760   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74761   float arg2 ;
74762
74763   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74764   arg2 = (float)jarg2;
74765   if (arg1) (arg1)->min = arg2;
74766 }
74767
74768
74769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
74770   float jresult ;
74771   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74772   float result;
74773
74774   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74775   result = (float) ((arg1)->min);
74776   jresult = result;
74777   return jresult;
74778 }
74779
74780
74781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
74782   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74783   float arg2 ;
74784
74785   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74786   arg2 = (float)jarg2;
74787   if (arg1) (arg1)->max = arg2;
74788 }
74789
74790
74791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
74792   float jresult ;
74793   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74794   float result;
74795
74796   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74797   result = (float) ((arg1)->max);
74798   jresult = result;
74799   return jresult;
74800 }
74801
74802
74803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
74804   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74805   bool arg2 ;
74806
74807   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74808   arg2 = jarg2 ? true : false;
74809   if (arg1) (arg1)->enabled = arg2;
74810 }
74811
74812
74813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
74814   unsigned int jresult ;
74815   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74816   bool result;
74817
74818   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74819   result = (bool) ((arg1)->enabled);
74820   jresult = result;
74821   return jresult;
74822 }
74823
74824
74825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
74826   float jresult ;
74827   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74828   float arg2 ;
74829   float arg3 ;
74830   float arg4 ;
74831   float result;
74832
74833   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74834   arg2 = (float)jarg2;
74835   arg3 = (float)jarg3;
74836   arg4 = (float)jarg4;
74837   {
74838     try {
74839       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
74840     } catch (std::out_of_range& e) {
74841       {
74842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74843       };
74844     } catch (std::exception& e) {
74845       {
74846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74847       };
74848     } catch (Dali::DaliException e) {
74849       {
74850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74851       };
74852     } catch (...) {
74853       {
74854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74855       };
74856     }
74857   }
74858
74859   jresult = result;
74860   return jresult;
74861 }
74862
74863
74864 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
74865   float jresult ;
74866   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74867   float arg2 ;
74868   float arg3 ;
74869   float result;
74870
74871   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74872   arg2 = (float)jarg2;
74873   arg3 = (float)jarg3;
74874   {
74875     try {
74876       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
74877     } catch (std::out_of_range& e) {
74878       {
74879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74880       };
74881     } catch (std::exception& e) {
74882       {
74883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74884       };
74885     } catch (Dali::DaliException e) {
74886       {
74887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74888       };
74889     } catch (...) {
74890       {
74891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74892       };
74893     }
74894   }
74895
74896   jresult = result;
74897   return jresult;
74898 }
74899
74900
74901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
74902   float jresult ;
74903   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74904   float arg2 ;
74905   float result;
74906
74907   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74908   arg2 = (float)jarg2;
74909   {
74910     try {
74911       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
74912     } catch (std::out_of_range& e) {
74913       {
74914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74915       };
74916     } catch (std::exception& e) {
74917       {
74918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74919       };
74920     } catch (Dali::DaliException e) {
74921       {
74922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74923       };
74924     } catch (...) {
74925       {
74926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74927       };
74928     }
74929   }
74930
74931   jresult = result;
74932   return jresult;
74933 }
74934
74935
74936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
74937   float jresult ;
74938   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74939   float arg2 ;
74940   float arg3 ;
74941   float arg4 ;
74942   Dali::Toolkit::ClampState *arg5 = 0 ;
74943   float result;
74944
74945   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74946   arg2 = (float)jarg2;
74947   arg3 = (float)jarg3;
74948   arg4 = (float)jarg4;
74949   arg5 = (Dali::Toolkit::ClampState *)jarg5;
74950   if (!arg5) {
74951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
74952     return 0;
74953   }
74954   {
74955     try {
74956       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
74957     } catch (std::out_of_range& e) {
74958       {
74959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74960       };
74961     } catch (std::exception& e) {
74962       {
74963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74964       };
74965     } catch (Dali::DaliException e) {
74966       {
74967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74968       };
74969     } catch (...) {
74970       {
74971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74972       };
74973     }
74974   }
74975
74976   jresult = result;
74977   return jresult;
74978 }
74979
74980
74981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
74982   float jresult ;
74983   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
74984   float result;
74985
74986   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
74987   {
74988     try {
74989       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
74990     } catch (std::out_of_range& e) {
74991       {
74992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74993       };
74994     } catch (std::exception& e) {
74995       {
74996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74997       };
74998     } catch (Dali::DaliException e) {
74999       {
75000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75001       };
75002     } catch (...) {
75003       {
75004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75005       };
75006     }
75007   }
75008
75009   jresult = result;
75010   return jresult;
75011 }
75012
75013
75014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
75015   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75016
75017   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75018   {
75019     try {
75020       delete arg1;
75021     } catch (std::out_of_range& e) {
75022       {
75023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75024       };
75025     } catch (std::exception& e) {
75026       {
75027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75028       };
75029     } catch (Dali::DaliException e) {
75030       {
75031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75032       };
75033     } catch (...) {
75034       {
75035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75036       };
75037     }
75038   }
75039
75040 }
75041
75042
75043 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
75044   float jresult ;
75045   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75046   float arg2 ;
75047   float arg3 ;
75048   float result;
75049
75050   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75051   arg2 = (float)jarg2;
75052   arg3 = (float)jarg3;
75053   {
75054     try {
75055       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
75056     } catch (std::out_of_range& e) {
75057       {
75058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75059       };
75060     } catch (std::exception& e) {
75061       {
75062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75063       };
75064     } catch (Dali::DaliException e) {
75065       {
75066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75067       };
75068     } catch (...) {
75069       {
75070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75071       };
75072     }
75073   }
75074
75075   jresult = result;
75076   return jresult;
75077 }
75078
75079
75080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
75081   float jresult ;
75082   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75083   float arg2 ;
75084   float result;
75085
75086   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75087   arg2 = (float)jarg2;
75088   {
75089     try {
75090       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
75091     } catch (std::out_of_range& e) {
75092       {
75093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75094       };
75095     } catch (std::exception& e) {
75096       {
75097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75098       };
75099     } catch (Dali::DaliException e) {
75100       {
75101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75102       };
75103     } catch (...) {
75104       {
75105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75106       };
75107     }
75108   }
75109
75110   jresult = result;
75111   return jresult;
75112 }
75113
75114
75115 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
75116   float jresult ;
75117   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75118   unsigned int arg2 ;
75119   unsigned int *arg3 = 0 ;
75120   bool arg4 ;
75121   float result;
75122
75123   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75124   arg2 = (unsigned int)jarg2;
75125   arg3 = (unsigned int *)jarg3;
75126   arg4 = jarg4 ? true : false;
75127   {
75128     try {
75129       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
75130     } catch (std::out_of_range& e) {
75131       {
75132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75133       };
75134     } catch (std::exception& e) {
75135       {
75136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75137       };
75138     } catch (Dali::DaliException e) {
75139       {
75140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75141       };
75142     } catch (...) {
75143       {
75144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75145       };
75146     }
75147   }
75148
75149   jresult = result;
75150   return jresult;
75151 }
75152
75153
75154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
75155   unsigned int jresult ;
75156   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75157   float arg2 ;
75158   bool arg3 ;
75159   unsigned int result;
75160
75161   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75162   arg2 = (float)jarg2;
75163   arg3 = jarg3 ? true : false;
75164   {
75165     try {
75166       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
75167     } catch (std::out_of_range& e) {
75168       {
75169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75170       };
75171     } catch (std::exception& e) {
75172       {
75173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75174       };
75175     } catch (Dali::DaliException e) {
75176       {
75177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75178       };
75179     } catch (...) {
75180       {
75181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75182       };
75183     }
75184   }
75185
75186   jresult = result;
75187   return jresult;
75188 }
75189
75190
75191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
75192   unsigned int jresult ;
75193   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75194   unsigned int result;
75195
75196   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75197   {
75198     try {
75199       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
75200     } catch (std::out_of_range& e) {
75201       {
75202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75203       };
75204     } catch (std::exception& e) {
75205       {
75206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75207       };
75208     } catch (Dali::DaliException e) {
75209       {
75210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75211       };
75212     } catch (...) {
75213       {
75214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75215       };
75216     }
75217   }
75218
75219   jresult = result;
75220   return jresult;
75221 }
75222
75223
75224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
75225   int jresult ;
75226   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75227   Dali::Toolkit::Ruler::RulerType result;
75228
75229   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75230   {
75231     try {
75232       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
75233     } catch (std::out_of_range& e) {
75234       {
75235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75236       };
75237     } catch (std::exception& e) {
75238       {
75239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75240       };
75241     } catch (Dali::DaliException e) {
75242       {
75243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75244       };
75245     } catch (...) {
75246       {
75247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75248       };
75249     }
75250   }
75251
75252   jresult = (int)result;
75253   return jresult;
75254 }
75255
75256
75257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
75258   unsigned int jresult ;
75259   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75260   bool result;
75261
75262   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75263   {
75264     try {
75265       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
75266     } catch (std::out_of_range& e) {
75267       {
75268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75269       };
75270     } catch (std::exception& e) {
75271       {
75272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75273       };
75274     } catch (Dali::DaliException e) {
75275       {
75276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75277       };
75278     } catch (...) {
75279       {
75280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75281       };
75282     }
75283   }
75284
75285   jresult = result;
75286   return jresult;
75287 }
75288
75289
75290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
75291   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75292
75293   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75294   {
75295     try {
75296       (arg1)->Enable();
75297     } catch (std::out_of_range& e) {
75298       {
75299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75300       };
75301     } catch (std::exception& e) {
75302       {
75303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75304       };
75305     } catch (Dali::DaliException e) {
75306       {
75307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75308       };
75309     } catch (...) {
75310       {
75311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75312       };
75313     }
75314   }
75315
75316 }
75317
75318
75319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
75320   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75321
75322   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75323   {
75324     try {
75325       (arg1)->Disable();
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 void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
75349   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75350   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
75351   Dali::Toolkit::RulerDomain *argp2 ;
75352
75353   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75354   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
75355   if (!argp2) {
75356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
75357     return ;
75358   }
75359   arg2 = *argp2;
75360   {
75361     try {
75362       (arg1)->SetDomain(arg2);
75363     } catch (std::out_of_range& e) {
75364       {
75365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75366       };
75367     } catch (std::exception& e) {
75368       {
75369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75370       };
75371     } catch (Dali::DaliException e) {
75372       {
75373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75374       };
75375     } catch (...) {
75376       {
75377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75378       };
75379     }
75380   }
75381
75382 }
75383
75384
75385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
75386   void * jresult ;
75387   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75388   Dali::Toolkit::RulerDomain *result = 0 ;
75389
75390   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75391   {
75392     try {
75393       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
75394     } catch (std::out_of_range& e) {
75395       {
75396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75397       };
75398     } catch (std::exception& e) {
75399       {
75400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75401       };
75402     } catch (Dali::DaliException e) {
75403       {
75404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75405       };
75406     } catch (...) {
75407       {
75408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75409       };
75410     }
75411   }
75412
75413   jresult = (void *)result;
75414   return jresult;
75415 }
75416
75417
75418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
75419   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75420
75421   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75422   {
75423     try {
75424       (arg1)->DisableDomain();
75425     } catch (std::out_of_range& e) {
75426       {
75427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75428       };
75429     } catch (std::exception& e) {
75430       {
75431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75432       };
75433     } catch (Dali::DaliException e) {
75434       {
75435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75436       };
75437     } catch (...) {
75438       {
75439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75440       };
75441     }
75442   }
75443
75444 }
75445
75446
75447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
75448   float jresult ;
75449   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75450   float arg2 ;
75451   float arg3 ;
75452   float arg4 ;
75453   float result;
75454
75455   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75456   arg2 = (float)jarg2;
75457   arg3 = (float)jarg3;
75458   arg4 = (float)jarg4;
75459   {
75460     try {
75461       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
75462     } catch (std::out_of_range& e) {
75463       {
75464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75465       };
75466     } catch (std::exception& e) {
75467       {
75468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75469       };
75470     } catch (Dali::DaliException e) {
75471       {
75472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75473       };
75474     } catch (...) {
75475       {
75476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75477       };
75478     }
75479   }
75480
75481   jresult = result;
75482   return jresult;
75483 }
75484
75485
75486 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
75487   float jresult ;
75488   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75489   float arg2 ;
75490   float arg3 ;
75491   float result;
75492
75493   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75494   arg2 = (float)jarg2;
75495   arg3 = (float)jarg3;
75496   {
75497     try {
75498       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
75499     } catch (std::out_of_range& e) {
75500       {
75501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75502       };
75503     } catch (std::exception& e) {
75504       {
75505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75506       };
75507     } catch (Dali::DaliException e) {
75508       {
75509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75510       };
75511     } catch (...) {
75512       {
75513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75514       };
75515     }
75516   }
75517
75518   jresult = result;
75519   return jresult;
75520 }
75521
75522
75523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
75524   float jresult ;
75525   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75526   float arg2 ;
75527   float result;
75528
75529   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75530   arg2 = (float)jarg2;
75531   {
75532     try {
75533       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
75534     } catch (std::out_of_range& e) {
75535       {
75536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75537       };
75538     } catch (std::exception& e) {
75539       {
75540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75541       };
75542     } catch (Dali::DaliException e) {
75543       {
75544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75545       };
75546     } catch (...) {
75547       {
75548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75549       };
75550     }
75551   }
75552
75553   jresult = result;
75554   return jresult;
75555 }
75556
75557
75558 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
75559   float jresult ;
75560   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75561   float arg2 ;
75562   float arg3 ;
75563   float arg4 ;
75564   Dali::Toolkit::ClampState *arg5 = 0 ;
75565   float result;
75566
75567   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75568   arg2 = (float)jarg2;
75569   arg3 = (float)jarg3;
75570   arg4 = (float)jarg4;
75571   arg5 = (Dali::Toolkit::ClampState *)jarg5;
75572   if (!arg5) {
75573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
75574     return 0;
75575   }
75576   {
75577     try {
75578       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
75579     } catch (std::out_of_range& e) {
75580       {
75581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75582       };
75583     } catch (std::exception& e) {
75584       {
75585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75586       };
75587     } catch (Dali::DaliException e) {
75588       {
75589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75590       };
75591     } catch (...) {
75592       {
75593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75594       };
75595     }
75596   }
75597
75598   jresult = result;
75599   return jresult;
75600 }
75601
75602
75603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
75604   float jresult ;
75605   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75606   float arg2 ;
75607   float arg3 ;
75608   float arg4 ;
75609   float arg5 ;
75610   float result;
75611
75612   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75613   arg2 = (float)jarg2;
75614   arg3 = (float)jarg3;
75615   arg4 = (float)jarg4;
75616   arg5 = (float)jarg5;
75617   {
75618     try {
75619       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
75620     } catch (std::out_of_range& e) {
75621       {
75622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75623       };
75624     } catch (std::exception& e) {
75625       {
75626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75627       };
75628     } catch (Dali::DaliException e) {
75629       {
75630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75631       };
75632     } catch (...) {
75633       {
75634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75635       };
75636     }
75637   }
75638
75639   jresult = result;
75640   return jresult;
75641 }
75642
75643
75644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
75645   float jresult ;
75646   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75647   float arg2 ;
75648   float arg3 ;
75649   float arg4 ;
75650   float result;
75651
75652   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75653   arg2 = (float)jarg2;
75654   arg3 = (float)jarg3;
75655   arg4 = (float)jarg4;
75656   {
75657     try {
75658       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
75659     } catch (std::out_of_range& e) {
75660       {
75661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75662       };
75663     } catch (std::exception& e) {
75664       {
75665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75666       };
75667     } catch (Dali::DaliException e) {
75668       {
75669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75670       };
75671     } catch (...) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75674       };
75675     }
75676   }
75677
75678   jresult = result;
75679   return jresult;
75680 }
75681
75682
75683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
75684   float jresult ;
75685   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75686   float arg2 ;
75687   float arg3 ;
75688   float result;
75689
75690   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75691   arg2 = (float)jarg2;
75692   arg3 = (float)jarg3;
75693   {
75694     try {
75695       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
75696     } catch (std::out_of_range& e) {
75697       {
75698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75699       };
75700     } catch (std::exception& e) {
75701       {
75702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75703       };
75704     } catch (Dali::DaliException e) {
75705       {
75706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75707       };
75708     } catch (...) {
75709       {
75710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75711       };
75712     }
75713   }
75714
75715   jresult = result;
75716   return jresult;
75717 }
75718
75719
75720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
75721   float jresult ;
75722   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75723   float arg2 ;
75724   float result;
75725
75726   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75727   arg2 = (float)jarg2;
75728   {
75729     try {
75730       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
75731     } catch (std::out_of_range& e) {
75732       {
75733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75734       };
75735     } catch (std::exception& e) {
75736       {
75737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75738       };
75739     } catch (Dali::DaliException e) {
75740       {
75741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75742       };
75743     } catch (...) {
75744       {
75745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75746       };
75747     }
75748   }
75749
75750   jresult = result;
75751   return jresult;
75752 }
75753
75754
75755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
75756   float jresult ;
75757   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75758   float arg2 ;
75759   float arg3 ;
75760   float arg4 ;
75761   float arg5 ;
75762   Dali::Toolkit::ClampState *arg6 = 0 ;
75763   float result;
75764
75765   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75766   arg2 = (float)jarg2;
75767   arg3 = (float)jarg3;
75768   arg4 = (float)jarg4;
75769   arg5 = (float)jarg5;
75770   arg6 = (Dali::Toolkit::ClampState *)jarg6;
75771   if (!arg6) {
75772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
75773     return 0;
75774   }
75775   {
75776     try {
75777       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
75778     } catch (std::out_of_range& e) {
75779       {
75780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75781       };
75782     } catch (std::exception& e) {
75783       {
75784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75785       };
75786     } catch (Dali::DaliException e) {
75787       {
75788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75789       };
75790     } catch (...) {
75791       {
75792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75793       };
75794     }
75795   }
75796
75797   jresult = result;
75798   return jresult;
75799 }
75800
75801
75802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
75803   void * jresult ;
75804   Dali::Toolkit::DefaultRuler *result = 0 ;
75805
75806   {
75807     try {
75808       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
75809     } catch (std::out_of_range& e) {
75810       {
75811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75812       };
75813     } catch (std::exception& e) {
75814       {
75815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75816       };
75817     } catch (Dali::DaliException e) {
75818       {
75819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75820       };
75821     } catch (...) {
75822       {
75823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75824       };
75825     }
75826   }
75827
75828   jresult = (void *)result;
75829   return jresult;
75830 }
75831
75832
75833 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
75834   float jresult ;
75835   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
75836   float arg2 ;
75837   float arg3 ;
75838   float result;
75839
75840   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
75841   arg2 = (float)jarg2;
75842   arg3 = (float)jarg3;
75843   {
75844     try {
75845       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
75846     } catch (std::out_of_range& e) {
75847       {
75848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75849       };
75850     } catch (std::exception& e) {
75851       {
75852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75853       };
75854     } catch (Dali::DaliException e) {
75855       {
75856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75857       };
75858     } catch (...) {
75859       {
75860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75861       };
75862     }
75863   }
75864
75865   jresult = result;
75866   return jresult;
75867 }
75868
75869
75870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
75871   float jresult ;
75872   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
75873   unsigned int arg2 ;
75874   unsigned int *arg3 = 0 ;
75875   bool arg4 ;
75876   float result;
75877
75878   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
75879   arg2 = (unsigned int)jarg2;
75880   arg3 = (unsigned int *)jarg3;
75881   arg4 = jarg4 ? true : false;
75882   {
75883     try {
75884       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
75885     } catch (std::out_of_range& e) {
75886       {
75887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75888       };
75889     } catch (std::exception& e) {
75890       {
75891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75892       };
75893     } catch (Dali::DaliException e) {
75894       {
75895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75896       };
75897     } catch (...) {
75898       {
75899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75900       };
75901     }
75902   }
75903
75904   jresult = result;
75905   return jresult;
75906 }
75907
75908
75909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
75910   unsigned int jresult ;
75911   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
75912   float arg2 ;
75913   bool arg3 ;
75914   unsigned int result;
75915
75916   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
75917   arg2 = (float)jarg2;
75918   arg3 = jarg3 ? true : false;
75919   {
75920     try {
75921       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
75922     } catch (std::out_of_range& e) {
75923       {
75924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75925       };
75926     } catch (std::exception& e) {
75927       {
75928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75929       };
75930     } catch (Dali::DaliException e) {
75931       {
75932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75933       };
75934     } catch (...) {
75935       {
75936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75937       };
75938     }
75939   }
75940
75941   jresult = result;
75942   return jresult;
75943 }
75944
75945
75946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
75947   unsigned int jresult ;
75948   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
75949   unsigned int result;
75950
75951   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
75952   {
75953     try {
75954       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
75955     } catch (std::out_of_range& e) {
75956       {
75957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75958       };
75959     } catch (std::exception& e) {
75960       {
75961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75962       };
75963     } catch (Dali::DaliException e) {
75964       {
75965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75966       };
75967     } catch (...) {
75968       {
75969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75970       };
75971     }
75972   }
75973
75974   jresult = result;
75975   return jresult;
75976 }
75977
75978
75979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
75980   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
75981
75982   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
75983   {
75984     try {
75985       delete arg1;
75986     } catch (std::out_of_range& e) {
75987       {
75988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75989       };
75990     } catch (std::exception& e) {
75991       {
75992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75993       };
75994     } catch (Dali::DaliException e) {
75995       {
75996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75997       };
75998     } catch (...) {
75999       {
76000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76001       };
76002     }
76003   }
76004
76005 }
76006
76007
76008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
76009   void * jresult ;
76010   float arg1 ;
76011   Dali::Toolkit::FixedRuler *result = 0 ;
76012
76013   arg1 = (float)jarg1;
76014   {
76015     try {
76016       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
76017     } catch (std::out_of_range& e) {
76018       {
76019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76020       };
76021     } catch (std::exception& e) {
76022       {
76023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76024       };
76025     } catch (Dali::DaliException e) {
76026       {
76027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76028       };
76029     } catch (...) {
76030       {
76031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76032       };
76033     }
76034   }
76035
76036   jresult = (void *)result;
76037   return jresult;
76038 }
76039
76040
76041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
76042   void * jresult ;
76043   Dali::Toolkit::FixedRuler *result = 0 ;
76044
76045   {
76046     try {
76047       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
76048     } catch (std::out_of_range& e) {
76049       {
76050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76051       };
76052     } catch (std::exception& e) {
76053       {
76054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76055       };
76056     } catch (Dali::DaliException e) {
76057       {
76058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76059       };
76060     } catch (...) {
76061       {
76062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76063       };
76064     }
76065   }
76066
76067   jresult = (void *)result;
76068   return jresult;
76069 }
76070
76071
76072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
76073   float jresult ;
76074   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
76075   float arg2 ;
76076   float arg3 ;
76077   float result;
76078
76079   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
76080   arg2 = (float)jarg2;
76081   arg3 = (float)jarg3;
76082   {
76083     try {
76084       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
76085     } catch (std::out_of_range& e) {
76086       {
76087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76088       };
76089     } catch (std::exception& e) {
76090       {
76091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76092       };
76093     } catch (Dali::DaliException e) {
76094       {
76095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76096       };
76097     } catch (...) {
76098       {
76099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76100       };
76101     }
76102   }
76103
76104   jresult = result;
76105   return jresult;
76106 }
76107
76108
76109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
76110   float jresult ;
76111   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
76112   unsigned int arg2 ;
76113   unsigned int *arg3 = 0 ;
76114   bool arg4 ;
76115   float result;
76116
76117   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
76118   arg2 = (unsigned int)jarg2;
76119   arg3 = (unsigned int *)jarg3;
76120   arg4 = jarg4 ? true : false;
76121   {
76122     try {
76123       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
76124     } catch (std::out_of_range& e) {
76125       {
76126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76127       };
76128     } catch (std::exception& e) {
76129       {
76130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76131       };
76132     } catch (Dali::DaliException e) {
76133       {
76134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76135       };
76136     } catch (...) {
76137       {
76138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76139       };
76140     }
76141   }
76142
76143   jresult = result;
76144   return jresult;
76145 }
76146
76147
76148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
76149   unsigned int jresult ;
76150   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
76151   float arg2 ;
76152   bool arg3 ;
76153   unsigned int result;
76154
76155   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
76156   arg2 = (float)jarg2;
76157   arg3 = jarg3 ? true : false;
76158   {
76159     try {
76160       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
76161     } catch (std::out_of_range& e) {
76162       {
76163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76164       };
76165     } catch (std::exception& e) {
76166       {
76167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76168       };
76169     } catch (Dali::DaliException e) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76172       };
76173     } catch (...) {
76174       {
76175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76176       };
76177     }
76178   }
76179
76180   jresult = result;
76181   return jresult;
76182 }
76183
76184
76185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
76186   unsigned int jresult ;
76187   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
76188   unsigned int result;
76189
76190   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
76191   {
76192     try {
76193       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
76194     } catch (std::out_of_range& e) {
76195       {
76196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76197       };
76198     } catch (std::exception& e) {
76199       {
76200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76201       };
76202     } catch (Dali::DaliException e) {
76203       {
76204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76205       };
76206     } catch (...) {
76207       {
76208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76209       };
76210     }
76211   }
76212
76213   jresult = result;
76214   return jresult;
76215 }
76216
76217
76218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
76219   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
76220
76221   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
76222   {
76223     try {
76224       delete arg1;
76225     } catch (std::out_of_range& e) {
76226       {
76227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76228       };
76229     } catch (std::exception& e) {
76230       {
76231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76232       };
76233     } catch (Dali::DaliException e) {
76234       {
76235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76236       };
76237     } catch (...) {
76238       {
76239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76240       };
76241     }
76242   }
76243
76244 }
76245
76246
76247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
76248   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76249   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
76250
76251   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76252   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
76253   if (arg1) (arg1)->scale = *arg2;
76254 }
76255
76256
76257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
76258   void * jresult ;
76259   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76260   Dali::Toolkit::ClampState2D *result = 0 ;
76261
76262   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76263   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
76264   jresult = (void *)result;
76265   return jresult;
76266 }
76267
76268
76269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
76270   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76271   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
76272
76273   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76274   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
76275   if (arg1) (arg1)->position = *arg2;
76276 }
76277
76278
76279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
76280   void * jresult ;
76281   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76282   Dali::Toolkit::ClampState2D *result = 0 ;
76283
76284   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76285   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
76286   jresult = (void *)result;
76287   return jresult;
76288 }
76289
76290
76291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
76292   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76293   Dali::Toolkit::ClampState arg2 ;
76294
76295   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76296   arg2 = (Dali::Toolkit::ClampState)jarg2;
76297   if (arg1) (arg1)->rotation = arg2;
76298 }
76299
76300
76301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
76302   int jresult ;
76303   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76304   Dali::Toolkit::ClampState result;
76305
76306   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76307   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
76308   jresult = (int)result;
76309   return jresult;
76310 }
76311
76312
76313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
76314   void * jresult ;
76315   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
76316
76317   {
76318     try {
76319       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
76320     } catch (std::out_of_range& e) {
76321       {
76322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76323       };
76324     } catch (std::exception& e) {
76325       {
76326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76327       };
76328     } catch (Dali::DaliException e) {
76329       {
76330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76331       };
76332     } catch (...) {
76333       {
76334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76335       };
76336     }
76337   }
76338
76339   jresult = (void *)result;
76340   return jresult;
76341 }
76342
76343
76344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
76345   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76346
76347   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76348   {
76349     try {
76350       delete arg1;
76351     } catch (std::out_of_range& e) {
76352       {
76353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76354       };
76355     } catch (std::exception& e) {
76356       {
76357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76358       };
76359     } catch (Dali::DaliException e) {
76360       {
76361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76362       };
76363     } catch (...) {
76364       {
76365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76366       };
76367     }
76368   }
76369
76370 }
76371
76372
76373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
76374   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
76375   Dali::Toolkit::SnapType arg2 ;
76376
76377   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
76378   arg2 = (Dali::Toolkit::SnapType)jarg2;
76379   if (arg1) (arg1)->type = arg2;
76380 }
76381
76382
76383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
76384   int jresult ;
76385   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
76386   Dali::Toolkit::SnapType result;
76387
76388   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
76389   result = (Dali::Toolkit::SnapType) ((arg1)->type);
76390   jresult = (int)result;
76391   return jresult;
76392 }
76393
76394
76395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
76396   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
76397   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
76398
76399   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
76400   arg2 = (Dali::Vector2 *)jarg2;
76401   if (arg1) (arg1)->position = *arg2;
76402 }
76403
76404
76405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
76406   void * jresult ;
76407   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
76408   Dali::Vector2 *result = 0 ;
76409
76410   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
76411   result = (Dali::Vector2 *)& ((arg1)->position);
76412   jresult = (void *)result;
76413   return jresult;
76414 }
76415
76416
76417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
76418   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
76419   float arg2 ;
76420
76421   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
76422   arg2 = (float)jarg2;
76423   if (arg1) (arg1)->duration = arg2;
76424 }
76425
76426
76427 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
76428   float jresult ;
76429   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
76430   float result;
76431
76432   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
76433   result = (float) ((arg1)->duration);
76434   jresult = result;
76435   return jresult;
76436 }
76437
76438
76439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
76440   void * jresult ;
76441   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
76442
76443   {
76444     try {
76445       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
76446     } catch (std::out_of_range& e) {
76447       {
76448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76449       };
76450     } catch (std::exception& e) {
76451       {
76452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76453       };
76454     } catch (Dali::DaliException e) {
76455       {
76456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76457       };
76458     } catch (...) {
76459       {
76460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76461       };
76462     }
76463   }
76464
76465   jresult = (void *)result;
76466   return jresult;
76467 }
76468
76469
76470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
76471   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
76472
76473   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
76474   {
76475     try {
76476       delete arg1;
76477     } catch (std::out_of_range& e) {
76478       {
76479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76480       };
76481     } catch (std::exception& e) {
76482       {
76483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76484       };
76485     } catch (Dali::DaliException e) {
76486       {
76487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76488       };
76489     } catch (...) {
76490       {
76491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76492       };
76493     }
76494   }
76495
76496 }
76497
76498
76499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
76500   int jresult ;
76501   int result;
76502
76503   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
76504   jresult = (int)result;
76505   return jresult;
76506 }
76507
76508
76509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
76510   int jresult ;
76511   int result;
76512
76513   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
76514   jresult = (int)result;
76515   return jresult;
76516 }
76517
76518
76519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
76520   int jresult ;
76521   int result;
76522
76523   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
76524   jresult = (int)result;
76525   return jresult;
76526 }
76527
76528
76529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76530   int jresult ;
76531   int result;
76532
76533   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76534   jresult = (int)result;
76535   return jresult;
76536 }
76537
76538
76539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
76540   int jresult ;
76541   int result;
76542
76543   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
76544   jresult = (int)result;
76545   return jresult;
76546 }
76547
76548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
76549   int jresult ;
76550   int result;
76551
76552   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
76553   jresult = (int)result;
76554   return jresult;
76555 }
76556
76557
76558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
76559   int jresult ;
76560   int result;
76561
76562   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
76563   jresult = (int)result;
76564   return jresult;
76565 }
76566
76567
76568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
76569   int jresult ;
76570   int result;
76571
76572   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
76573   jresult = (int)result;
76574   return jresult;
76575 }
76576
76577
76578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
76579   int jresult ;
76580   int result;
76581
76582   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
76583   jresult = (int)result;
76584   return jresult;
76585 }
76586
76587
76588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
76589   int jresult ;
76590   int result;
76591
76592   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
76593   jresult = (int)result;
76594   return jresult;
76595 }
76596
76597
76598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
76599   int jresult ;
76600   int result;
76601
76602   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
76603   jresult = (int)result;
76604   return jresult;
76605 }
76606
76607
76608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
76609   int jresult ;
76610   int result;
76611
76612   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
76613   jresult = (int)result;
76614   return jresult;
76615 }
76616
76617
76618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
76619   int jresult ;
76620   int result;
76621
76622   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
76623   jresult = (int)result;
76624   return jresult;
76625 }
76626
76627
76628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
76629   int jresult ;
76630   int result;
76631
76632   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
76633   jresult = (int)result;
76634   return jresult;
76635 }
76636
76637
76638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
76639   int jresult ;
76640   int result;
76641
76642   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
76643   jresult = (int)result;
76644   return jresult;
76645 }
76646
76647
76648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
76649   int jresult ;
76650   int result;
76651
76652   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
76653   jresult = (int)result;
76654   return jresult;
76655 }
76656
76657
76658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
76659   int jresult ;
76660   int result;
76661
76662   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
76663   jresult = (int)result;
76664   return jresult;
76665 }
76666
76667
76668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
76669   int jresult ;
76670   int result;
76671
76672   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
76673   jresult = (int)result;
76674   return jresult;
76675 }
76676
76677
76678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
76679   int jresult ;
76680   int result;
76681
76682   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
76683   jresult = (int)result;
76684   return jresult;
76685 }
76686
76687
76688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
76689   int jresult ;
76690   int result;
76691
76692   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
76693   jresult = (int)result;
76694   return jresult;
76695 }
76696
76697
76698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
76699   int jresult ;
76700   int result;
76701
76702   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
76703   jresult = (int)result;
76704   return jresult;
76705 }
76706
76707
76708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
76709   int jresult ;
76710   int result;
76711
76712   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
76713   jresult = (int)result;
76714   return jresult;
76715 }
76716
76717
76718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
76719   int jresult ;
76720   int result;
76721
76722   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
76723   jresult = (int)result;
76724   return jresult;
76725 }
76726
76727
76728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
76729   int jresult ;
76730   int result;
76731
76732   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
76733   jresult = (int)result;
76734   return jresult;
76735 }
76736
76737
76738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
76739   int jresult ;
76740   int result;
76741
76742   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
76743   jresult = (int)result;
76744   return jresult;
76745 }
76746
76747
76748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
76749   int jresult ;
76750   int result;
76751
76752   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
76753   jresult = (int)result;
76754   return jresult;
76755 }
76756
76757
76758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
76759   void * jresult ;
76760   Dali::Toolkit::ScrollView::Property *result = 0 ;
76761
76762   {
76763     try {
76764       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
76765     } catch (std::out_of_range& e) {
76766       {
76767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76768       };
76769     } catch (std::exception& e) {
76770       {
76771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76772       };
76773     } catch (Dali::DaliException e) {
76774       {
76775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76776       };
76777     } catch (...) {
76778       {
76779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76780       };
76781     }
76782   }
76783
76784   jresult = (void *)result;
76785   return jresult;
76786 }
76787
76788
76789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
76790   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
76791
76792   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
76793   {
76794     try {
76795       delete arg1;
76796     } catch (std::out_of_range& e) {
76797       {
76798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76799       };
76800     } catch (std::exception& e) {
76801       {
76802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76803       };
76804     } catch (Dali::DaliException e) {
76805       {
76806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76807       };
76808     } catch (...) {
76809       {
76810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76811       };
76812     }
76813   }
76814
76815 }
76816
76817
76818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
76819   void * jresult ;
76820   Dali::Toolkit::ScrollView *result = 0 ;
76821
76822   {
76823     try {
76824       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
76825     } catch (std::out_of_range& e) {
76826       {
76827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76828       };
76829     } catch (std::exception& e) {
76830       {
76831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76832       };
76833     } catch (Dali::DaliException e) {
76834       {
76835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76836       };
76837     } catch (...) {
76838       {
76839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76840       };
76841     }
76842   }
76843
76844   jresult = (void *)result;
76845   return jresult;
76846 }
76847
76848
76849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
76850   void * jresult ;
76851   Dali::Toolkit::ScrollView *arg1 = 0 ;
76852   Dali::Toolkit::ScrollView *result = 0 ;
76853
76854   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76855   if (!arg1) {
76856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
76857     return 0;
76858   }
76859   {
76860     try {
76861       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
76862     } catch (std::out_of_range& e) {
76863       {
76864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76865       };
76866     } catch (std::exception& e) {
76867       {
76868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76869       };
76870     } catch (Dali::DaliException e) {
76871       {
76872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76873       };
76874     } catch (...) {
76875       {
76876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76877       };
76878     }
76879   }
76880
76881   jresult = (void *)result;
76882   return jresult;
76883 }
76884
76885
76886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
76887   void * jresult ;
76888   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76889   Dali::Toolkit::ScrollView *arg2 = 0 ;
76890   Dali::Toolkit::ScrollView *result = 0 ;
76891
76892   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76893   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
76894   if (!arg2) {
76895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
76896     return 0;
76897   }
76898   {
76899     try {
76900       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
76901     } catch (std::out_of_range& e) {
76902       {
76903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76904       };
76905     } catch (std::exception& e) {
76906       {
76907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76908       };
76909     } catch (Dali::DaliException e) {
76910       {
76911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76912       };
76913     } catch (...) {
76914       {
76915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76916       };
76917     }
76918   }
76919
76920   jresult = (void *)result;
76921   return jresult;
76922 }
76923
76924
76925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
76926   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76927
76928   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76929   {
76930     try {
76931       delete arg1;
76932     } catch (std::out_of_range& e) {
76933       {
76934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76935       };
76936     } catch (std::exception& e) {
76937       {
76938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76939       };
76940     } catch (Dali::DaliException e) {
76941       {
76942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76943       };
76944     } catch (...) {
76945       {
76946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76947       };
76948     }
76949   }
76950
76951 }
76952
76953
76954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
76955   void * jresult ;
76956   Dali::Toolkit::ScrollView result;
76957
76958   {
76959     try {
76960       result = Dali::Toolkit::ScrollView::New();
76961     } catch (std::out_of_range& e) {
76962       {
76963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76964       };
76965     } catch (std::exception& e) {
76966       {
76967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76968       };
76969     } catch (Dali::DaliException e) {
76970       {
76971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76972       };
76973     } catch (...) {
76974       {
76975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76976       };
76977     }
76978   }
76979
76980   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
76981   return jresult;
76982 }
76983
76984
76985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
76986   void * jresult ;
76987   Dali::BaseHandle arg1 ;
76988   Dali::BaseHandle *argp1 ;
76989   Dali::Toolkit::ScrollView result;
76990
76991   argp1 = (Dali::BaseHandle *)jarg1;
76992   if (!argp1) {
76993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76994     return 0;
76995   }
76996   arg1 = *argp1;
76997   {
76998     try {
76999       result = Dali::Toolkit::ScrollView::DownCast(arg1);
77000     } catch (std::out_of_range& e) {
77001       {
77002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77003       };
77004     } catch (std::exception& e) {
77005       {
77006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77007       };
77008     } catch (Dali::DaliException e) {
77009       {
77010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77011       };
77012     } catch (...) {
77013       {
77014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77015       };
77016     }
77017   }
77018
77019   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
77020   return jresult;
77021 }
77022
77023
77024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
77025   void * jresult ;
77026   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77027   Dali::AlphaFunction result;
77028
77029   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77030   {
77031     try {
77032       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
77033     } catch (std::out_of_range& e) {
77034       {
77035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77036       };
77037     } catch (std::exception& e) {
77038       {
77039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77040       };
77041     } catch (Dali::DaliException e) {
77042       {
77043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77044       };
77045     } catch (...) {
77046       {
77047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77048       };
77049     }
77050   }
77051
77052   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
77053   return jresult;
77054 }
77055
77056
77057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
77058   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77059   Dali::AlphaFunction arg2 ;
77060   Dali::AlphaFunction *argp2 ;
77061
77062   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77063   argp2 = (Dali::AlphaFunction *)jarg2;
77064   if (!argp2) {
77065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
77066     return ;
77067   }
77068   arg2 = *argp2;
77069   {
77070     try {
77071       (arg1)->SetScrollSnapAlphaFunction(arg2);
77072     } catch (std::out_of_range& e) {
77073       {
77074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77075       };
77076     } catch (std::exception& e) {
77077       {
77078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77079       };
77080     } catch (Dali::DaliException e) {
77081       {
77082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77083       };
77084     } catch (...) {
77085       {
77086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77087       };
77088     }
77089   }
77090
77091 }
77092
77093
77094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
77095   void * jresult ;
77096   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77097   Dali::AlphaFunction result;
77098
77099   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77100   {
77101     try {
77102       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
77103     } catch (std::out_of_range& e) {
77104       {
77105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77106       };
77107     } catch (std::exception& e) {
77108       {
77109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77110       };
77111     } catch (Dali::DaliException e) {
77112       {
77113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77114       };
77115     } catch (...) {
77116       {
77117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77118       };
77119     }
77120   }
77121
77122   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
77123   return jresult;
77124 }
77125
77126
77127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
77128   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77129   Dali::AlphaFunction arg2 ;
77130   Dali::AlphaFunction *argp2 ;
77131
77132   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77133   argp2 = (Dali::AlphaFunction *)jarg2;
77134   if (!argp2) {
77135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
77136     return ;
77137   }
77138   arg2 = *argp2;
77139   {
77140     try {
77141       (arg1)->SetScrollFlickAlphaFunction(arg2);
77142     } catch (std::out_of_range& e) {
77143       {
77144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77145       };
77146     } catch (std::exception& e) {
77147       {
77148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77149       };
77150     } catch (Dali::DaliException e) {
77151       {
77152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77153       };
77154     } catch (...) {
77155       {
77156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77157       };
77158     }
77159   }
77160
77161 }
77162
77163
77164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
77165   float jresult ;
77166   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77167   float result;
77168
77169   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77170   {
77171     try {
77172       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
77173     } catch (std::out_of_range& e) {
77174       {
77175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77176       };
77177     } catch (std::exception& e) {
77178       {
77179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77180       };
77181     } catch (Dali::DaliException e) {
77182       {
77183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77184       };
77185     } catch (...) {
77186       {
77187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77188       };
77189     }
77190   }
77191
77192   jresult = result;
77193   return jresult;
77194 }
77195
77196
77197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
77198   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77199   float arg2 ;
77200
77201   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77202   arg2 = (float)jarg2;
77203   {
77204     try {
77205       (arg1)->SetScrollSnapDuration(arg2);
77206     } catch (std::out_of_range& e) {
77207       {
77208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77209       };
77210     } catch (std::exception& e) {
77211       {
77212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77213       };
77214     } catch (Dali::DaliException e) {
77215       {
77216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77217       };
77218     } catch (...) {
77219       {
77220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77221       };
77222     }
77223   }
77224
77225 }
77226
77227
77228 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
77229   float jresult ;
77230   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77231   float result;
77232
77233   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77234   {
77235     try {
77236       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
77237     } catch (std::out_of_range& e) {
77238       {
77239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77240       };
77241     } catch (std::exception& e) {
77242       {
77243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77244       };
77245     } catch (Dali::DaliException e) {
77246       {
77247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77248       };
77249     } catch (...) {
77250       {
77251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77252       };
77253     }
77254   }
77255
77256   jresult = result;
77257   return jresult;
77258 }
77259
77260
77261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
77262   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77263   float arg2 ;
77264
77265   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77266   arg2 = (float)jarg2;
77267   {
77268     try {
77269       (arg1)->SetScrollFlickDuration(arg2);
77270     } catch (std::out_of_range& e) {
77271       {
77272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77273       };
77274     } catch (std::exception& e) {
77275       {
77276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77277       };
77278     } catch (Dali::DaliException e) {
77279       {
77280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77281       };
77282     } catch (...) {
77283       {
77284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77285       };
77286     }
77287   }
77288
77289 }
77290
77291
77292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
77293   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77294   Dali::Toolkit::RulerPtr arg2 ;
77295   Dali::Toolkit::RulerPtr *argp2 ;
77296
77297   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77298   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
77299   if (!argp2) {
77300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
77301     return ;
77302   }
77303   arg2 = *argp2;
77304   {
77305     try {
77306       (arg1)->SetRulerX(arg2);
77307     } catch (std::out_of_range& e) {
77308       {
77309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77310       };
77311     } catch (std::exception& e) {
77312       {
77313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77314       };
77315     } catch (Dali::DaliException e) {
77316       {
77317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77318       };
77319     } catch (...) {
77320       {
77321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77322       };
77323     }
77324   }
77325
77326 }
77327
77328
77329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
77330   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77331   Dali::Toolkit::RulerPtr arg2 ;
77332   Dali::Toolkit::RulerPtr *argp2 ;
77333
77334   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77335   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
77336   if (!argp2) {
77337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
77338     return ;
77339   }
77340   arg2 = *argp2;
77341   {
77342     try {
77343       (arg1)->SetRulerY(arg2);
77344     } catch (std::out_of_range& e) {
77345       {
77346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77347       };
77348     } catch (std::exception& e) {
77349       {
77350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77351       };
77352     } catch (Dali::DaliException e) {
77353       {
77354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77355       };
77356     } catch (...) {
77357       {
77358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77359       };
77360     }
77361   }
77362
77363 }
77364
77365
77366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
77367   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77368   bool arg2 ;
77369
77370   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77371   arg2 = jarg2 ? true : false;
77372   {
77373     try {
77374       (arg1)->SetScrollSensitive(arg2);
77375     } catch (std::out_of_range& e) {
77376       {
77377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77378       };
77379     } catch (std::exception& e) {
77380       {
77381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77382       };
77383     } catch (Dali::DaliException e) {
77384       {
77385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77386       };
77387     } catch (...) {
77388       {
77389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77390       };
77391     }
77392   }
77393
77394 }
77395
77396
77397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
77398   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77399   float arg2 ;
77400   float arg3 ;
77401
77402   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77403   arg2 = (float)jarg2;
77404   arg3 = (float)jarg3;
77405   {
77406     try {
77407       (arg1)->SetMaxOvershoot(arg2,arg3);
77408     } catch (std::out_of_range& e) {
77409       {
77410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77411       };
77412     } catch (std::exception& e) {
77413       {
77414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77415       };
77416     } catch (Dali::DaliException e) {
77417       {
77418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77419       };
77420     } catch (...) {
77421       {
77422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77423       };
77424     }
77425   }
77426
77427 }
77428
77429
77430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
77431   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77432   Dali::AlphaFunction arg2 ;
77433   Dali::AlphaFunction *argp2 ;
77434
77435   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77436   argp2 = (Dali::AlphaFunction *)jarg2;
77437   if (!argp2) {
77438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
77439     return ;
77440   }
77441   arg2 = *argp2;
77442   {
77443     try {
77444       (arg1)->SetSnapOvershootAlphaFunction(arg2);
77445     } catch (std::out_of_range& e) {
77446       {
77447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77448       };
77449     } catch (std::exception& e) {
77450       {
77451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77452       };
77453     } catch (Dali::DaliException e) {
77454       {
77455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77456       };
77457     } catch (...) {
77458       {
77459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77460       };
77461     }
77462   }
77463
77464 }
77465
77466
77467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
77468   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77469   float arg2 ;
77470
77471   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77472   arg2 = (float)jarg2;
77473   {
77474     try {
77475       (arg1)->SetSnapOvershootDuration(arg2);
77476     } catch (std::out_of_range& e) {
77477       {
77478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77479       };
77480     } catch (std::exception& e) {
77481       {
77482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77483       };
77484     } catch (Dali::DaliException e) {
77485       {
77486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77487       };
77488     } catch (...) {
77489       {
77490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77491       };
77492     }
77493   }
77494
77495 }
77496
77497
77498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
77499   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77500   bool arg2 ;
77501
77502   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77503   arg2 = jarg2 ? true : false;
77504   {
77505     try {
77506       (arg1)->SetActorAutoSnap(arg2);
77507     } catch (std::out_of_range& e) {
77508       {
77509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77510       };
77511     } catch (std::exception& e) {
77512       {
77513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77514       };
77515     } catch (Dali::DaliException e) {
77516       {
77517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77518       };
77519     } catch (...) {
77520       {
77521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77522       };
77523     }
77524   }
77525
77526 }
77527
77528
77529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
77530   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77531   bool arg2 ;
77532
77533   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77534   arg2 = jarg2 ? true : false;
77535   {
77536     try {
77537       (arg1)->SetWrapMode(arg2);
77538     } catch (std::out_of_range& e) {
77539       {
77540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77541       };
77542     } catch (std::exception& e) {
77543       {
77544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77545       };
77546     } catch (Dali::DaliException e) {
77547       {
77548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77549       };
77550     } catch (...) {
77551       {
77552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77553       };
77554     }
77555   }
77556
77557 }
77558
77559
77560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
77561   int jresult ;
77562   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77563   int result;
77564
77565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77566   {
77567     try {
77568       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
77569     } catch (std::out_of_range& e) {
77570       {
77571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77572       };
77573     } catch (std::exception& e) {
77574       {
77575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77576       };
77577     } catch (Dali::DaliException e) {
77578       {
77579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77580       };
77581     } catch (...) {
77582       {
77583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77584       };
77585     }
77586   }
77587
77588   jresult = result;
77589   return jresult;
77590 }
77591
77592
77593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
77594   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77595   int arg2 ;
77596
77597   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77598   arg2 = (int)jarg2;
77599   {
77600     try {
77601       (arg1)->SetScrollUpdateDistance(arg2);
77602     } catch (std::out_of_range& e) {
77603       {
77604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77605       };
77606     } catch (std::exception& e) {
77607       {
77608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77609       };
77610     } catch (Dali::DaliException e) {
77611       {
77612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77613       };
77614     } catch (...) {
77615       {
77616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77617       };
77618     }
77619   }
77620
77621 }
77622
77623
77624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
77625   unsigned int jresult ;
77626   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77627   bool result;
77628
77629   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77630   {
77631     try {
77632       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
77633     } catch (std::out_of_range& e) {
77634       {
77635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77636       };
77637     } catch (std::exception& e) {
77638       {
77639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77640       };
77641     } catch (Dali::DaliException e) {
77642       {
77643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77644       };
77645     } catch (...) {
77646       {
77647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77648       };
77649     }
77650   }
77651
77652   jresult = result;
77653   return jresult;
77654 }
77655
77656
77657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
77658   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77659   bool arg2 ;
77660
77661   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77662   arg2 = jarg2 ? true : false;
77663   {
77664     try {
77665       (arg1)->SetAxisAutoLock(arg2);
77666     } catch (std::out_of_range& e) {
77667       {
77668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77669       };
77670     } catch (std::exception& e) {
77671       {
77672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77673       };
77674     } catch (Dali::DaliException e) {
77675       {
77676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77677       };
77678     } catch (...) {
77679       {
77680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77681       };
77682     }
77683   }
77684
77685 }
77686
77687
77688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
77689   float jresult ;
77690   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77691   float result;
77692
77693   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77694   {
77695     try {
77696       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
77697     } catch (std::out_of_range& e) {
77698       {
77699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77700       };
77701     } catch (std::exception& e) {
77702       {
77703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77704       };
77705     } catch (Dali::DaliException e) {
77706       {
77707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77708       };
77709     } catch (...) {
77710       {
77711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77712       };
77713     }
77714   }
77715
77716   jresult = result;
77717   return jresult;
77718 }
77719
77720
77721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
77722   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77723   float arg2 ;
77724
77725   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77726   arg2 = (float)jarg2;
77727   {
77728     try {
77729       (arg1)->SetAxisAutoLockGradient(arg2);
77730     } catch (std::out_of_range& e) {
77731       {
77732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77733       };
77734     } catch (std::exception& e) {
77735       {
77736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77737       };
77738     } catch (Dali::DaliException e) {
77739       {
77740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77741       };
77742     } catch (...) {
77743       {
77744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77745       };
77746     }
77747   }
77748
77749 }
77750
77751
77752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
77753   float jresult ;
77754   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77755   float result;
77756
77757   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77758   {
77759     try {
77760       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
77761     } catch (std::out_of_range& e) {
77762       {
77763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77764       };
77765     } catch (std::exception& e) {
77766       {
77767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77768       };
77769     } catch (Dali::DaliException e) {
77770       {
77771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77772       };
77773     } catch (...) {
77774       {
77775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77776       };
77777     }
77778   }
77779
77780   jresult = result;
77781   return jresult;
77782 }
77783
77784
77785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
77786   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77787   float arg2 ;
77788
77789   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77790   arg2 = (float)jarg2;
77791   {
77792     try {
77793       (arg1)->SetFrictionCoefficient(arg2);
77794     } catch (std::out_of_range& e) {
77795       {
77796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77797       };
77798     } catch (std::exception& e) {
77799       {
77800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77801       };
77802     } catch (Dali::DaliException e) {
77803       {
77804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77805       };
77806     } catch (...) {
77807       {
77808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77809       };
77810     }
77811   }
77812
77813 }
77814
77815
77816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
77817   float jresult ;
77818   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77819   float result;
77820
77821   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77822   {
77823     try {
77824       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
77825     } catch (std::out_of_range& e) {
77826       {
77827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77828       };
77829     } catch (std::exception& e) {
77830       {
77831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77832       };
77833     } catch (Dali::DaliException e) {
77834       {
77835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77836       };
77837     } catch (...) {
77838       {
77839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77840       };
77841     }
77842   }
77843
77844   jresult = result;
77845   return jresult;
77846 }
77847
77848
77849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
77850   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77851   float arg2 ;
77852
77853   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77854   arg2 = (float)jarg2;
77855   {
77856     try {
77857       (arg1)->SetFlickSpeedCoefficient(arg2);
77858     } catch (std::out_of_range& e) {
77859       {
77860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77861       };
77862     } catch (std::exception& e) {
77863       {
77864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77865       };
77866     } catch (Dali::DaliException e) {
77867       {
77868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77869       };
77870     } catch (...) {
77871       {
77872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77873       };
77874     }
77875   }
77876
77877 }
77878
77879
77880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
77881   void * jresult ;
77882   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77883   Dali::Vector2 result;
77884
77885   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77886   {
77887     try {
77888       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
77889     } catch (std::out_of_range& e) {
77890       {
77891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77892       };
77893     } catch (std::exception& e) {
77894       {
77895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77896       };
77897     } catch (Dali::DaliException e) {
77898       {
77899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77900       };
77901     } catch (...) {
77902       {
77903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77904       };
77905     }
77906   }
77907
77908   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
77909   return jresult;
77910 }
77911
77912
77913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
77914   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77915   Dali::Vector2 *arg2 = 0 ;
77916
77917   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77918   arg2 = (Dali::Vector2 *)jarg2;
77919   if (!arg2) {
77920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
77921     return ;
77922   }
77923   {
77924     try {
77925       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
77926     } catch (std::out_of_range& e) {
77927       {
77928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77929       };
77930     } catch (std::exception& e) {
77931       {
77932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77933       };
77934     } catch (Dali::DaliException e) {
77935       {
77936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77937       };
77938     } catch (...) {
77939       {
77940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77941       };
77942     }
77943   }
77944
77945 }
77946
77947
77948 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
77949   float jresult ;
77950   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77951   float result;
77952
77953   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77954   {
77955     try {
77956       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
77957     } catch (std::out_of_range& e) {
77958       {
77959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77960       };
77961     } catch (std::exception& e) {
77962       {
77963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77964       };
77965     } catch (Dali::DaliException e) {
77966       {
77967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77968       };
77969     } catch (...) {
77970       {
77971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77972       };
77973     }
77974   }
77975
77976   jresult = result;
77977   return jresult;
77978 }
77979
77980
77981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
77982   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77983   float arg2 ;
77984
77985   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77986   arg2 = (float)jarg2;
77987   {
77988     try {
77989       (arg1)->SetMinimumSpeedForFlick(arg2);
77990     } catch (std::out_of_range& e) {
77991       {
77992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77993       };
77994     } catch (std::exception& e) {
77995       {
77996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77997       };
77998     } catch (Dali::DaliException e) {
77999       {
78000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78001       };
78002     } catch (...) {
78003       {
78004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78005       };
78006     }
78007   }
78008
78009 }
78010
78011
78012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
78013   float jresult ;
78014   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78015   float result;
78016
78017   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78018   {
78019     try {
78020       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
78021     } catch (std::out_of_range& e) {
78022       {
78023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78024       };
78025     } catch (std::exception& e) {
78026       {
78027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78028       };
78029     } catch (Dali::DaliException e) {
78030       {
78031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78032       };
78033     } catch (...) {
78034       {
78035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78036       };
78037     }
78038   }
78039
78040   jresult = result;
78041   return jresult;
78042 }
78043
78044
78045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
78046   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78047   float arg2 ;
78048
78049   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78050   arg2 = (float)jarg2;
78051   {
78052     try {
78053       (arg1)->SetMaxFlickSpeed(arg2);
78054     } catch (std::out_of_range& e) {
78055       {
78056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78057       };
78058     } catch (std::exception& e) {
78059       {
78060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78061       };
78062     } catch (Dali::DaliException e) {
78063       {
78064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78065       };
78066     } catch (...) {
78067       {
78068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78069       };
78070     }
78071   }
78072
78073 }
78074
78075
78076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
78077   void * jresult ;
78078   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78079   Dali::Vector2 result;
78080
78081   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78082   {
78083     try {
78084       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
78085     } catch (std::out_of_range& e) {
78086       {
78087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78088       };
78089     } catch (std::exception& e) {
78090       {
78091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78092       };
78093     } catch (Dali::DaliException e) {
78094       {
78095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78096       };
78097     } catch (...) {
78098       {
78099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78100       };
78101     }
78102   }
78103
78104   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
78105   return jresult;
78106 }
78107
78108
78109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
78110   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78111   Dali::Vector2 arg2 ;
78112   Dali::Vector2 *argp2 ;
78113
78114   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78115   argp2 = (Dali::Vector2 *)jarg2;
78116   if (!argp2) {
78117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
78118     return ;
78119   }
78120   arg2 = *argp2;
78121   {
78122     try {
78123       (arg1)->SetWheelScrollDistanceStep(arg2);
78124     } catch (std::out_of_range& e) {
78125       {
78126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78127       };
78128     } catch (std::exception& e) {
78129       {
78130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78131       };
78132     } catch (Dali::DaliException e) {
78133       {
78134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78135       };
78136     } catch (...) {
78137       {
78138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78139       };
78140     }
78141   }
78142
78143 }
78144
78145
78146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
78147   void * jresult ;
78148   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78149   Dali::Vector2 result;
78150
78151   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78152   {
78153     try {
78154       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
78155     } catch (std::out_of_range& e) {
78156       {
78157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78158       };
78159     } catch (std::exception& e) {
78160       {
78161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78162       };
78163     } catch (Dali::DaliException e) {
78164       {
78165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78166       };
78167     } catch (...) {
78168       {
78169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78170       };
78171     }
78172   }
78173
78174   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
78175   return jresult;
78176 }
78177
78178
78179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
78180   unsigned int jresult ;
78181   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78182   unsigned int result;
78183
78184   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78185   {
78186     try {
78187       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
78188     } catch (std::out_of_range& e) {
78189       {
78190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78191       };
78192     } catch (std::exception& e) {
78193       {
78194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78195       };
78196     } catch (Dali::DaliException e) {
78197       {
78198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78199       };
78200     } catch (...) {
78201       {
78202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78203       };
78204     }
78205   }
78206
78207   jresult = result;
78208   return jresult;
78209 }
78210
78211
78212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
78213   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78214   Dali::Vector2 *arg2 = 0 ;
78215
78216   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78217   arg2 = (Dali::Vector2 *)jarg2;
78218   if (!arg2) {
78219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78220     return ;
78221   }
78222   {
78223     try {
78224       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
78225     } catch (std::out_of_range& e) {
78226       {
78227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78228       };
78229     } catch (std::exception& e) {
78230       {
78231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78232       };
78233     } catch (Dali::DaliException e) {
78234       {
78235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78236       };
78237     } catch (...) {
78238       {
78239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78240       };
78241     }
78242   }
78243
78244 }
78245
78246
78247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
78248   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78249   Dali::Vector2 *arg2 = 0 ;
78250   float arg3 ;
78251
78252   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78253   arg2 = (Dali::Vector2 *)jarg2;
78254   if (!arg2) {
78255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78256     return ;
78257   }
78258   arg3 = (float)jarg3;
78259   {
78260     try {
78261       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
78262     } catch (std::out_of_range& e) {
78263       {
78264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78265       };
78266     } catch (std::exception& e) {
78267       {
78268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78269       };
78270     } catch (Dali::DaliException e) {
78271       {
78272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78273       };
78274     } catch (...) {
78275       {
78276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78277       };
78278     }
78279   }
78280
78281 }
78282
78283
78284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
78285   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78286   Dali::Vector2 *arg2 = 0 ;
78287   float arg3 ;
78288   Dali::AlphaFunction arg4 ;
78289   Dali::AlphaFunction *argp4 ;
78290
78291   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78292   arg2 = (Dali::Vector2 *)jarg2;
78293   if (!arg2) {
78294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78295     return ;
78296   }
78297   arg3 = (float)jarg3;
78298   argp4 = (Dali::AlphaFunction *)jarg4;
78299   if (!argp4) {
78300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
78301     return ;
78302   }
78303   arg4 = *argp4;
78304   {
78305     try {
78306       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
78307     } catch (std::out_of_range& e) {
78308       {
78309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78310       };
78311     } catch (std::exception& e) {
78312       {
78313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78314       };
78315     } catch (Dali::DaliException e) {
78316       {
78317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78318       };
78319     } catch (...) {
78320       {
78321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78322       };
78323     }
78324   }
78325
78326 }
78327
78328
78329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
78330   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78331   Dali::Vector2 *arg2 = 0 ;
78332   float arg3 ;
78333   Dali::Toolkit::DirectionBias arg4 ;
78334   Dali::Toolkit::DirectionBias arg5 ;
78335
78336   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78337   arg2 = (Dali::Vector2 *)jarg2;
78338   if (!arg2) {
78339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78340     return ;
78341   }
78342   arg3 = (float)jarg3;
78343   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
78344   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
78345   {
78346     try {
78347       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
78348     } catch (std::out_of_range& e) {
78349       {
78350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78351       };
78352     } catch (std::exception& e) {
78353       {
78354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78355       };
78356     } catch (Dali::DaliException e) {
78357       {
78358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78359       };
78360     } catch (...) {
78361       {
78362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78363       };
78364     }
78365   }
78366
78367 }
78368
78369
78370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
78371   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78372   Dali::Vector2 *arg2 = 0 ;
78373   float arg3 ;
78374   Dali::AlphaFunction arg4 ;
78375   Dali::Toolkit::DirectionBias arg5 ;
78376   Dali::Toolkit::DirectionBias arg6 ;
78377   Dali::AlphaFunction *argp4 ;
78378
78379   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78380   arg2 = (Dali::Vector2 *)jarg2;
78381   if (!arg2) {
78382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78383     return ;
78384   }
78385   arg3 = (float)jarg3;
78386   argp4 = (Dali::AlphaFunction *)jarg4;
78387   if (!argp4) {
78388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
78389     return ;
78390   }
78391   arg4 = *argp4;
78392   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
78393   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
78394   {
78395     try {
78396       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
78397     } catch (std::out_of_range& e) {
78398       {
78399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78400       };
78401     } catch (std::exception& e) {
78402       {
78403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78404       };
78405     } catch (Dali::DaliException e) {
78406       {
78407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78408       };
78409     } catch (...) {
78410       {
78411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78412       };
78413     }
78414   }
78415
78416 }
78417
78418
78419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
78420   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78421   unsigned int arg2 ;
78422
78423   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78424   arg2 = (unsigned int)jarg2;
78425   {
78426     try {
78427       (arg1)->ScrollTo(arg2);
78428     } catch (std::out_of_range& e) {
78429       {
78430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78431       };
78432     } catch (std::exception& e) {
78433       {
78434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78435       };
78436     } catch (Dali::DaliException e) {
78437       {
78438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78439       };
78440     } catch (...) {
78441       {
78442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78443       };
78444     }
78445   }
78446
78447 }
78448
78449
78450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
78451   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78452   unsigned int arg2 ;
78453   float arg3 ;
78454
78455   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78456   arg2 = (unsigned int)jarg2;
78457   arg3 = (float)jarg3;
78458   {
78459     try {
78460       (arg1)->ScrollTo(arg2,arg3);
78461     } catch (std::out_of_range& e) {
78462       {
78463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78464       };
78465     } catch (std::exception& e) {
78466       {
78467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78468       };
78469     } catch (Dali::DaliException e) {
78470       {
78471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78472       };
78473     } catch (...) {
78474       {
78475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78476       };
78477     }
78478   }
78479
78480 }
78481
78482
78483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
78484   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78485   unsigned int arg2 ;
78486   float arg3 ;
78487   Dali::Toolkit::DirectionBias arg4 ;
78488
78489   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78490   arg2 = (unsigned int)jarg2;
78491   arg3 = (float)jarg3;
78492   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
78493   {
78494     try {
78495       (arg1)->ScrollTo(arg2,arg3,arg4);
78496     } catch (std::out_of_range& e) {
78497       {
78498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78499       };
78500     } catch (std::exception& e) {
78501       {
78502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78503       };
78504     } catch (Dali::DaliException e) {
78505       {
78506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78507       };
78508     } catch (...) {
78509       {
78510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78511       };
78512     }
78513   }
78514
78515 }
78516
78517
78518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
78519   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78520   Dali::Actor *arg2 = 0 ;
78521
78522   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78523   arg2 = (Dali::Actor *)jarg2;
78524   if (!arg2) {
78525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
78526     return ;
78527   }
78528   {
78529     try {
78530       (arg1)->ScrollTo(*arg2);
78531     } catch (std::out_of_range& e) {
78532       {
78533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78534       };
78535     } catch (std::exception& e) {
78536       {
78537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78538       };
78539     } catch (Dali::DaliException e) {
78540       {
78541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78542       };
78543     } catch (...) {
78544       {
78545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78546       };
78547     }
78548   }
78549
78550 }
78551
78552
78553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
78554   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78555   Dali::Actor *arg2 = 0 ;
78556   float arg3 ;
78557
78558   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78559   arg2 = (Dali::Actor *)jarg2;
78560   if (!arg2) {
78561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
78562     return ;
78563   }
78564   arg3 = (float)jarg3;
78565   {
78566     try {
78567       (arg1)->ScrollTo(*arg2,arg3);
78568     } catch (std::out_of_range& e) {
78569       {
78570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78571       };
78572     } catch (std::exception& e) {
78573       {
78574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78575       };
78576     } catch (Dali::DaliException e) {
78577       {
78578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78579       };
78580     } catch (...) {
78581       {
78582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78583       };
78584     }
78585   }
78586
78587 }
78588
78589
78590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
78591   unsigned int jresult ;
78592   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78593   bool result;
78594
78595   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78596   {
78597     try {
78598       result = (bool)(arg1)->ScrollToSnapPoint();
78599     } catch (std::out_of_range& e) {
78600       {
78601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78602       };
78603     } catch (std::exception& e) {
78604       {
78605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78606       };
78607     } catch (Dali::DaliException e) {
78608       {
78609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78610       };
78611     } catch (...) {
78612       {
78613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78614       };
78615     }
78616   }
78617
78618   jresult = result;
78619   return jresult;
78620 }
78621
78622
78623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
78624   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78625   Dali::Constraint arg2 ;
78626   Dali::Constraint *argp2 ;
78627
78628   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78629   argp2 = (Dali::Constraint *)jarg2;
78630   if (!argp2) {
78631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
78632     return ;
78633   }
78634   arg2 = *argp2;
78635   {
78636     try {
78637       (arg1)->ApplyConstraintToChildren(arg2);
78638     } catch (std::out_of_range& e) {
78639       {
78640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78641       };
78642     } catch (std::exception& e) {
78643       {
78644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78645       };
78646     } catch (Dali::DaliException e) {
78647       {
78648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78649       };
78650     } catch (...) {
78651       {
78652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78653       };
78654     }
78655   }
78656
78657 }
78658
78659
78660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
78661   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78662
78663   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78664   {
78665     try {
78666       (arg1)->RemoveConstraintsFromChildren();
78667     } catch (std::out_of_range& e) {
78668       {
78669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78670       };
78671     } catch (std::exception& e) {
78672       {
78673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78674       };
78675     } catch (Dali::DaliException e) {
78676       {
78677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78678       };
78679     } catch (...) {
78680       {
78681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78682       };
78683     }
78684   }
78685
78686 }
78687
78688
78689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
78690   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78691   Dali::Toolkit::ScrollViewEffect arg2 ;
78692   Dali::Toolkit::ScrollViewEffect *argp2 ;
78693
78694   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78695   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
78696   if (!argp2) {
78697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
78698     return ;
78699   }
78700   arg2 = *argp2;
78701   {
78702     try {
78703       (arg1)->ApplyEffect(arg2);
78704     } catch (std::out_of_range& e) {
78705       {
78706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78707       };
78708     } catch (std::exception& e) {
78709       {
78710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78711       };
78712     } catch (Dali::DaliException e) {
78713       {
78714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78715       };
78716     } catch (...) {
78717       {
78718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78719       };
78720     }
78721   }
78722
78723 }
78724
78725
78726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
78727   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78728   Dali::Toolkit::ScrollViewEffect arg2 ;
78729   Dali::Toolkit::ScrollViewEffect *argp2 ;
78730
78731   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78732   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
78733   if (!argp2) {
78734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
78735     return ;
78736   }
78737   arg2 = *argp2;
78738   {
78739     try {
78740       (arg1)->RemoveEffect(arg2);
78741     } catch (std::out_of_range& e) {
78742       {
78743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78744       };
78745     } catch (std::exception& e) {
78746       {
78747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78748       };
78749     } catch (Dali::DaliException e) {
78750       {
78751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78752       };
78753     } catch (...) {
78754       {
78755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78756       };
78757     }
78758   }
78759
78760 }
78761
78762
78763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
78764   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78765
78766   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78767   {
78768     try {
78769       (arg1)->RemoveAllEffects();
78770     } catch (std::out_of_range& e) {
78771       {
78772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78773       };
78774     } catch (std::exception& e) {
78775       {
78776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78777       };
78778     } catch (Dali::DaliException e) {
78779       {
78780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78781       };
78782     } catch (...) {
78783       {
78784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78785       };
78786     }
78787   }
78788
78789 }
78790
78791
78792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
78793   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78794   Dali::Actor arg2 ;
78795   Dali::Actor *argp2 ;
78796
78797   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78798   argp2 = (Dali::Actor *)jarg2;
78799   if (!argp2) {
78800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78801     return ;
78802   }
78803   arg2 = *argp2;
78804   {
78805     try {
78806       (arg1)->BindActor(arg2);
78807     } catch (std::out_of_range& e) {
78808       {
78809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78810       };
78811     } catch (std::exception& e) {
78812       {
78813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78814       };
78815     } catch (Dali::DaliException e) {
78816       {
78817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78818       };
78819     } catch (...) {
78820       {
78821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78822       };
78823     }
78824   }
78825
78826 }
78827
78828
78829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
78830   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78831   Dali::Actor arg2 ;
78832   Dali::Actor *argp2 ;
78833
78834   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78835   argp2 = (Dali::Actor *)jarg2;
78836   if (!argp2) {
78837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78838     return ;
78839   }
78840   arg2 = *argp2;
78841   {
78842     try {
78843       (arg1)->UnbindActor(arg2);
78844     } catch (std::out_of_range& e) {
78845       {
78846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78847       };
78848     } catch (std::exception& e) {
78849       {
78850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78851       };
78852     } catch (Dali::DaliException e) {
78853       {
78854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78855       };
78856     } catch (...) {
78857       {
78858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78859       };
78860     }
78861   }
78862
78863 }
78864
78865
78866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
78867   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78868   Dali::Radian arg2 ;
78869   Dali::Radian arg3 ;
78870   Dali::Radian *argp2 ;
78871   Dali::Radian *argp3 ;
78872
78873   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78874   argp2 = (Dali::Radian *)jarg2;
78875   if (!argp2) {
78876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
78877     return ;
78878   }
78879   arg2 = *argp2;
78880   argp3 = (Dali::Radian *)jarg3;
78881   if (!argp3) {
78882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
78883     return ;
78884   }
78885   arg3 = *argp3;
78886   {
78887     try {
78888       (arg1)->SetScrollingDirection(arg2,arg3);
78889     } catch (std::out_of_range& e) {
78890       {
78891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78892       };
78893     } catch (std::exception& e) {
78894       {
78895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78896       };
78897     } catch (Dali::DaliException e) {
78898       {
78899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78900       };
78901     } catch (...) {
78902       {
78903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78904       };
78905     }
78906   }
78907
78908 }
78909
78910
78911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
78912   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78913   Dali::Radian arg2 ;
78914   Dali::Radian *argp2 ;
78915
78916   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78917   argp2 = (Dali::Radian *)jarg2;
78918   if (!argp2) {
78919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
78920     return ;
78921   }
78922   arg2 = *argp2;
78923   {
78924     try {
78925       (arg1)->SetScrollingDirection(arg2);
78926     } catch (std::out_of_range& e) {
78927       {
78928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78929       };
78930     } catch (std::exception& e) {
78931       {
78932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78933       };
78934     } catch (Dali::DaliException e) {
78935       {
78936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78937       };
78938     } catch (...) {
78939       {
78940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78941       };
78942     }
78943   }
78944
78945 }
78946
78947
78948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
78949   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78950   Dali::Radian arg2 ;
78951   Dali::Radian *argp2 ;
78952
78953   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78954   argp2 = (Dali::Radian *)jarg2;
78955   if (!argp2) {
78956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
78957     return ;
78958   }
78959   arg2 = *argp2;
78960   {
78961     try {
78962       (arg1)->RemoveScrollingDirection(arg2);
78963     } catch (std::out_of_range& e) {
78964       {
78965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78966       };
78967     } catch (std::exception& e) {
78968       {
78969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78970       };
78971     } catch (Dali::DaliException e) {
78972       {
78973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78974       };
78975     } catch (...) {
78976       {
78977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78978       };
78979     }
78980   }
78981
78982 }
78983
78984
78985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
78986   void * jresult ;
78987   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78988   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
78989
78990   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78991   {
78992     try {
78993       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
78994     } catch (std::out_of_range& e) {
78995       {
78996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78997       };
78998     } catch (std::exception& e) {
78999       {
79000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79001       };
79002     } catch (Dali::DaliException e) {
79003       {
79004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79005       };
79006     } catch (...) {
79007       {
79008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79009       };
79010     }
79011   }
79012
79013   jresult = (void *)result;
79014   return jresult;
79015 }
79016
79017
79018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
79019   int jresult ;
79020   int result;
79021
79022   result = (int)Dali::Toolkit::TableView::Property::ROWS;
79023   jresult = (int)result;
79024   return jresult;
79025 }
79026
79027
79028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
79029   int jresult ;
79030   int result;
79031
79032   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
79033   jresult = (int)result;
79034   return jresult;
79035 }
79036
79037
79038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
79039   int jresult ;
79040   int result;
79041
79042   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
79043   jresult = (int)result;
79044   return jresult;
79045 }
79046
79047
79048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
79049   int jresult ;
79050   int result;
79051
79052   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
79053   jresult = (int)result;
79054   return jresult;
79055 }
79056
79057
79058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
79059   int jresult ;
79060   int result;
79061
79062   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
79063   jresult = (int)result;
79064   return jresult;
79065 }
79066
79067
79068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
79069   void * jresult ;
79070   Dali::Toolkit::TableView::Property *result = 0 ;
79071
79072   {
79073     try {
79074       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
79075     } catch (std::out_of_range& e) {
79076       {
79077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79078       };
79079     } catch (std::exception& e) {
79080       {
79081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79082       };
79083     } catch (Dali::DaliException e) {
79084       {
79085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79086       };
79087     } catch (...) {
79088       {
79089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79090       };
79091     }
79092   }
79093
79094   jresult = (void *)result;
79095   return jresult;
79096 }
79097
79098
79099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
79100   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
79101
79102   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
79103   {
79104     try {
79105       delete arg1;
79106     } catch (std::out_of_range& e) {
79107       {
79108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79109       };
79110     } catch (std::exception& e) {
79111       {
79112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79113       };
79114     } catch (Dali::DaliException e) {
79115       {
79116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79117       };
79118     } catch (...) {
79119       {
79120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79121       };
79122     }
79123   }
79124
79125 }
79126
79127
79128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
79129   int jresult ;
79130   int result;
79131
79132   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
79133   jresult = (int)result;
79134   return jresult;
79135 }
79136
79137
79138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
79139   int jresult ;
79140   int result;
79141
79142   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
79143   jresult = (int)result;
79144   return jresult;
79145 }
79146
79147
79148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
79149   int jresult ;
79150   int result;
79151
79152   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
79153   jresult = (int)result;
79154   return jresult;
79155 }
79156
79157
79158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
79159   int jresult ;
79160   int result;
79161
79162   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
79163   jresult = (int)result;
79164   return jresult;
79165 }
79166
79167
79168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
79169   int jresult ;
79170   int result;
79171
79172   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
79173   jresult = (int)result;
79174   return jresult;
79175 }
79176
79177
79178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
79179   void * jresult ;
79180   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
79181
79182   {
79183     try {
79184       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
79185     } catch (std::out_of_range& e) {
79186       {
79187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79188       };
79189     } catch (std::exception& e) {
79190       {
79191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79192       };
79193     } catch (Dali::DaliException e) {
79194       {
79195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79196       };
79197     } catch (...) {
79198       {
79199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79200       };
79201     }
79202   }
79203
79204   jresult = (void *)result;
79205   return jresult;
79206 }
79207
79208
79209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
79210   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
79211
79212   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
79213   {
79214     try {
79215       delete arg1;
79216     } catch (std::out_of_range& e) {
79217       {
79218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79219       };
79220     } catch (std::exception& e) {
79221       {
79222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79223       };
79224     } catch (Dali::DaliException e) {
79225       {
79226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79227       };
79228     } catch (...) {
79229       {
79230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79231       };
79232     }
79233   }
79234
79235 }
79236
79237
79238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
79239   void * jresult ;
79240   unsigned int arg1 ;
79241   unsigned int arg2 ;
79242   unsigned int arg3 ;
79243   unsigned int arg4 ;
79244   Dali::Toolkit::TableView::CellPosition *result = 0 ;
79245
79246   arg1 = (unsigned int)jarg1;
79247   arg2 = (unsigned int)jarg2;
79248   arg3 = (unsigned int)jarg3;
79249   arg4 = (unsigned int)jarg4;
79250   {
79251     try {
79252       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
79253     } catch (std::out_of_range& e) {
79254       {
79255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79256       };
79257     } catch (std::exception& e) {
79258       {
79259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79260       };
79261     } catch (Dali::DaliException e) {
79262       {
79263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79264       };
79265     } catch (...) {
79266       {
79267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79268       };
79269     }
79270   }
79271
79272   jresult = (void *)result;
79273   return jresult;
79274 }
79275
79276
79277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
79278   void * jresult ;
79279   unsigned int arg1 ;
79280   unsigned int arg2 ;
79281   unsigned int arg3 ;
79282   Dali::Toolkit::TableView::CellPosition *result = 0 ;
79283
79284   arg1 = (unsigned int)jarg1;
79285   arg2 = (unsigned int)jarg2;
79286   arg3 = (unsigned int)jarg3;
79287   {
79288     try {
79289       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
79290     } catch (std::out_of_range& e) {
79291       {
79292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79293       };
79294     } catch (std::exception& e) {
79295       {
79296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79297       };
79298     } catch (Dali::DaliException e) {
79299       {
79300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79301       };
79302     } catch (...) {
79303       {
79304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79305       };
79306     }
79307   }
79308
79309   jresult = (void *)result;
79310   return jresult;
79311 }
79312
79313
79314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
79315   void * jresult ;
79316   unsigned int arg1 ;
79317   unsigned int arg2 ;
79318   Dali::Toolkit::TableView::CellPosition *result = 0 ;
79319
79320   arg1 = (unsigned int)jarg1;
79321   arg2 = (unsigned int)jarg2;
79322   {
79323     try {
79324       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
79325     } catch (std::out_of_range& e) {
79326       {
79327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79328       };
79329     } catch (std::exception& e) {
79330       {
79331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79332       };
79333     } catch (Dali::DaliException e) {
79334       {
79335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79336       };
79337     } catch (...) {
79338       {
79339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79340       };
79341     }
79342   }
79343
79344   jresult = (void *)result;
79345   return jresult;
79346 }
79347
79348
79349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
79350   void * jresult ;
79351   unsigned int arg1 ;
79352   Dali::Toolkit::TableView::CellPosition *result = 0 ;
79353
79354   arg1 = (unsigned int)jarg1;
79355   {
79356     try {
79357       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
79358     } catch (std::out_of_range& e) {
79359       {
79360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79361       };
79362     } catch (std::exception& e) {
79363       {
79364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79365       };
79366     } catch (Dali::DaliException e) {
79367       {
79368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79369       };
79370     } catch (...) {
79371       {
79372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79373       };
79374     }
79375   }
79376
79377   jresult = (void *)result;
79378   return jresult;
79379 }
79380
79381
79382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
79383   void * jresult ;
79384   Dali::Toolkit::TableView::CellPosition *result = 0 ;
79385
79386   {
79387     try {
79388       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
79389     } catch (std::out_of_range& e) {
79390       {
79391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79392       };
79393     } catch (std::exception& e) {
79394       {
79395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79396       };
79397     } catch (Dali::DaliException e) {
79398       {
79399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79400       };
79401     } catch (...) {
79402       {
79403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79404       };
79405     }
79406   }
79407
79408   jresult = (void *)result;
79409   return jresult;
79410 }
79411
79412
79413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
79414   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
79415   unsigned int arg2 ;
79416
79417   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
79418   arg2 = (unsigned int)jarg2;
79419   if (arg1) (arg1)->rowIndex = arg2;
79420 }
79421
79422
79423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
79424   unsigned int jresult ;
79425   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
79426   unsigned int result;
79427
79428   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
79429   result = (unsigned int) ((arg1)->rowIndex);
79430   jresult = result;
79431   return jresult;
79432 }
79433
79434
79435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
79436   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
79437   unsigned int arg2 ;
79438
79439   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
79440   arg2 = (unsigned int)jarg2;
79441   if (arg1) (arg1)->columnIndex = arg2;
79442 }
79443
79444
79445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
79446   unsigned int jresult ;
79447   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
79448   unsigned int result;
79449
79450   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
79451   result = (unsigned int) ((arg1)->columnIndex);
79452   jresult = result;
79453   return jresult;
79454 }
79455
79456
79457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
79458   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
79459   unsigned int arg2 ;
79460
79461   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
79462   arg2 = (unsigned int)jarg2;
79463   if (arg1) (arg1)->rowSpan = arg2;
79464 }
79465
79466
79467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
79468   unsigned int jresult ;
79469   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
79470   unsigned int result;
79471
79472   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
79473   result = (unsigned int) ((arg1)->rowSpan);
79474   jresult = result;
79475   return jresult;
79476 }
79477
79478
79479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
79480   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
79481   unsigned int arg2 ;
79482
79483   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
79484   arg2 = (unsigned int)jarg2;
79485   if (arg1) (arg1)->columnSpan = arg2;
79486 }
79487
79488
79489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
79490   unsigned int jresult ;
79491   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
79492   unsigned int result;
79493
79494   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
79495   result = (unsigned int) ((arg1)->columnSpan);
79496   jresult = result;
79497   return jresult;
79498 }
79499
79500
79501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
79502   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
79503
79504   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
79505   {
79506     try {
79507       delete arg1;
79508     } catch (std::out_of_range& e) {
79509       {
79510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79511       };
79512     } catch (std::exception& e) {
79513       {
79514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79515       };
79516     } catch (Dali::DaliException e) {
79517       {
79518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79519       };
79520     } catch (...) {
79521       {
79522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79523       };
79524     }
79525   }
79526
79527 }
79528
79529
79530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
79531   void * jresult ;
79532   Dali::Toolkit::TableView *result = 0 ;
79533
79534   {
79535     try {
79536       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
79537     } catch (std::out_of_range& e) {
79538       {
79539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79540       };
79541     } catch (std::exception& e) {
79542       {
79543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79544       };
79545     } catch (Dali::DaliException e) {
79546       {
79547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79548       };
79549     } catch (...) {
79550       {
79551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79552       };
79553     }
79554   }
79555
79556   jresult = (void *)result;
79557   return jresult;
79558 }
79559
79560
79561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
79562   void * jresult ;
79563   Dali::Toolkit::TableView *arg1 = 0 ;
79564   Dali::Toolkit::TableView *result = 0 ;
79565
79566   arg1 = (Dali::Toolkit::TableView *)jarg1;
79567   if (!arg1) {
79568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
79569     return 0;
79570   }
79571   {
79572     try {
79573       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
79574     } catch (std::out_of_range& e) {
79575       {
79576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79577       };
79578     } catch (std::exception& e) {
79579       {
79580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79581       };
79582     } catch (Dali::DaliException e) {
79583       {
79584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79585       };
79586     } catch (...) {
79587       {
79588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79589       };
79590     }
79591   }
79592
79593   jresult = (void *)result;
79594   return jresult;
79595 }
79596
79597
79598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
79599   void * jresult ;
79600   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79601   Dali::Toolkit::TableView *arg2 = 0 ;
79602   Dali::Toolkit::TableView *result = 0 ;
79603
79604   arg1 = (Dali::Toolkit::TableView *)jarg1;
79605   arg2 = (Dali::Toolkit::TableView *)jarg2;
79606   if (!arg2) {
79607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
79608     return 0;
79609   }
79610   {
79611     try {
79612       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
79613     } catch (std::out_of_range& e) {
79614       {
79615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79616       };
79617     } catch (std::exception& e) {
79618       {
79619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79620       };
79621     } catch (Dali::DaliException e) {
79622       {
79623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79624       };
79625     } catch (...) {
79626       {
79627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79628       };
79629     }
79630   }
79631
79632   jresult = (void *)result;
79633   return jresult;
79634 }
79635
79636
79637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
79638   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79639
79640   arg1 = (Dali::Toolkit::TableView *)jarg1;
79641   {
79642     try {
79643       delete arg1;
79644     } catch (std::out_of_range& e) {
79645       {
79646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79647       };
79648     } catch (std::exception& e) {
79649       {
79650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79651       };
79652     } catch (Dali::DaliException e) {
79653       {
79654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79655       };
79656     } catch (...) {
79657       {
79658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79659       };
79660     }
79661   }
79662
79663 }
79664
79665
79666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
79667   void * jresult ;
79668   unsigned int arg1 ;
79669   unsigned int arg2 ;
79670   Dali::Toolkit::TableView result;
79671
79672   arg1 = (unsigned int)jarg1;
79673   arg2 = (unsigned int)jarg2;
79674   {
79675     try {
79676       result = Dali::Toolkit::TableView::New(arg1,arg2);
79677     } catch (std::out_of_range& e) {
79678       {
79679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79680       };
79681     } catch (std::exception& e) {
79682       {
79683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79684       };
79685     } catch (Dali::DaliException e) {
79686       {
79687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79688       };
79689     } catch (...) {
79690       {
79691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79692       };
79693     }
79694   }
79695
79696   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
79697   return jresult;
79698 }
79699
79700
79701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
79702   void * jresult ;
79703   Dali::BaseHandle arg1 ;
79704   Dali::BaseHandle *argp1 ;
79705   Dali::Toolkit::TableView result;
79706
79707   argp1 = (Dali::BaseHandle *)jarg1;
79708   if (!argp1) {
79709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79710     return 0;
79711   }
79712   arg1 = *argp1;
79713   {
79714     try {
79715       result = Dali::Toolkit::TableView::DownCast(arg1);
79716     } catch (std::out_of_range& e) {
79717       {
79718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79719       };
79720     } catch (std::exception& e) {
79721       {
79722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79723       };
79724     } catch (Dali::DaliException e) {
79725       {
79726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79727       };
79728     } catch (...) {
79729       {
79730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79731       };
79732     }
79733   }
79734
79735   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
79736   return jresult;
79737 }
79738
79739
79740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
79741   unsigned int jresult ;
79742   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79743   Dali::Actor arg2 ;
79744   Dali::Toolkit::TableView::CellPosition arg3 ;
79745   Dali::Actor *argp2 ;
79746   Dali::Toolkit::TableView::CellPosition *argp3 ;
79747   bool result;
79748
79749   arg1 = (Dali::Toolkit::TableView *)jarg1;
79750   argp2 = (Dali::Actor *)jarg2;
79751   if (!argp2) {
79752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79753     return 0;
79754   }
79755   arg2 = *argp2;
79756   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
79757   if (!argp3) {
79758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
79759     return 0;
79760   }
79761   arg3 = *argp3;
79762   {
79763     try {
79764       result = (bool)(arg1)->AddChild(arg2,arg3);
79765     } catch (std::out_of_range& e) {
79766       {
79767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79768       };
79769     } catch (std::exception& e) {
79770       {
79771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79772       };
79773     } catch (Dali::DaliException e) {
79774       {
79775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79776       };
79777     } catch (...) {
79778       {
79779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79780       };
79781     }
79782   }
79783
79784   jresult = result;
79785   return jresult;
79786 }
79787
79788
79789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
79790   void * jresult ;
79791   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79792   Dali::Toolkit::TableView::CellPosition arg2 ;
79793   Dali::Toolkit::TableView::CellPosition *argp2 ;
79794   Dali::Actor result;
79795
79796   arg1 = (Dali::Toolkit::TableView *)jarg1;
79797   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
79798   if (!argp2) {
79799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
79800     return 0;
79801   }
79802   arg2 = *argp2;
79803   {
79804     try {
79805       result = (arg1)->GetChildAt(arg2);
79806     } catch (std::out_of_range& e) {
79807       {
79808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79809       };
79810     } catch (std::exception& e) {
79811       {
79812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79813       };
79814     } catch (Dali::DaliException e) {
79815       {
79816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79817       };
79818     } catch (...) {
79819       {
79820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79821       };
79822     }
79823   }
79824
79825   jresult = new Dali::Actor((const Dali::Actor &)result);
79826   return jresult;
79827 }
79828
79829
79830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
79831   void * jresult ;
79832   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79833   Dali::Toolkit::TableView::CellPosition arg2 ;
79834   Dali::Toolkit::TableView::CellPosition *argp2 ;
79835   Dali::Actor result;
79836
79837   arg1 = (Dali::Toolkit::TableView *)jarg1;
79838   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
79839   if (!argp2) {
79840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
79841     return 0;
79842   }
79843   arg2 = *argp2;
79844   {
79845     try {
79846       result = (arg1)->RemoveChildAt(arg2);
79847     } catch (std::out_of_range& e) {
79848       {
79849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79850       };
79851     } catch (std::exception& e) {
79852       {
79853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79854       };
79855     } catch (Dali::DaliException e) {
79856       {
79857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79858       };
79859     } catch (...) {
79860       {
79861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79862       };
79863     }
79864   }
79865
79866   jresult = new Dali::Actor((const Dali::Actor &)result);
79867   return jresult;
79868 }
79869
79870
79871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
79872   unsigned int jresult ;
79873   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79874   Dali::Actor arg2 ;
79875   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
79876   Dali::Actor *argp2 ;
79877   bool result;
79878
79879   arg1 = (Dali::Toolkit::TableView *)jarg1;
79880   argp2 = (Dali::Actor *)jarg2;
79881   if (!argp2) {
79882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79883     return 0;
79884   }
79885   arg2 = *argp2;
79886   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
79887   if (!arg3) {
79888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
79889     return 0;
79890   }
79891   {
79892     try {
79893       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
79894     } catch (std::out_of_range& e) {
79895       {
79896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79897       };
79898     } catch (std::exception& e) {
79899       {
79900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79901       };
79902     } catch (Dali::DaliException e) {
79903       {
79904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79905       };
79906     } catch (...) {
79907       {
79908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79909       };
79910     }
79911   }
79912
79913   jresult = result;
79914   return jresult;
79915 }
79916
79917
79918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
79919   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79920   unsigned int arg2 ;
79921
79922   arg1 = (Dali::Toolkit::TableView *)jarg1;
79923   arg2 = (unsigned int)jarg2;
79924   {
79925     try {
79926       (arg1)->InsertRow(arg2);
79927     } catch (std::out_of_range& e) {
79928       {
79929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79930       };
79931     } catch (std::exception& e) {
79932       {
79933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79934       };
79935     } catch (Dali::DaliException e) {
79936       {
79937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79938       };
79939     } catch (...) {
79940       {
79941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79942       };
79943     }
79944   }
79945
79946 }
79947
79948
79949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
79950   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79951   unsigned int arg2 ;
79952
79953   arg1 = (Dali::Toolkit::TableView *)jarg1;
79954   arg2 = (unsigned int)jarg2;
79955   {
79956     try {
79957       (arg1)->DeleteRow(arg2);
79958     } catch (std::out_of_range& e) {
79959       {
79960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79961       };
79962     } catch (std::exception& e) {
79963       {
79964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79965       };
79966     } catch (Dali::DaliException e) {
79967       {
79968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79969       };
79970     } catch (...) {
79971       {
79972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79973       };
79974     }
79975   }
79976
79977 }
79978
79979
79980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
79981   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
79982   unsigned int arg2 ;
79983   std::vector< Dali::Actor > *arg3 = 0 ;
79984
79985   arg1 = (Dali::Toolkit::TableView *)jarg1;
79986   arg2 = (unsigned int)jarg2;
79987   arg3 = (std::vector< Dali::Actor > *)jarg3;
79988   if (!arg3) {
79989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
79990     return ;
79991   }
79992   {
79993     try {
79994       (arg1)->DeleteRow(arg2,*arg3);
79995     } catch (std::out_of_range& e) {
79996       {
79997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79998       };
79999     } catch (std::exception& e) {
80000       {
80001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80002       };
80003     } catch (Dali::DaliException e) {
80004       {
80005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80006       };
80007     } catch (...) {
80008       {
80009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80010       };
80011     }
80012   }
80013
80014 }
80015
80016
80017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
80018   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80019   unsigned int arg2 ;
80020
80021   arg1 = (Dali::Toolkit::TableView *)jarg1;
80022   arg2 = (unsigned int)jarg2;
80023   {
80024     try {
80025       (arg1)->InsertColumn(arg2);
80026     } catch (std::out_of_range& e) {
80027       {
80028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80029       };
80030     } catch (std::exception& e) {
80031       {
80032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80033       };
80034     } catch (Dali::DaliException e) {
80035       {
80036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80037       };
80038     } catch (...) {
80039       {
80040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80041       };
80042     }
80043   }
80044
80045 }
80046
80047
80048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
80049   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80050   unsigned int arg2 ;
80051
80052   arg1 = (Dali::Toolkit::TableView *)jarg1;
80053   arg2 = (unsigned int)jarg2;
80054   {
80055     try {
80056       (arg1)->DeleteColumn(arg2);
80057     } catch (std::out_of_range& e) {
80058       {
80059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80060       };
80061     } catch (std::exception& e) {
80062       {
80063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80064       };
80065     } catch (Dali::DaliException e) {
80066       {
80067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80068       };
80069     } catch (...) {
80070       {
80071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80072       };
80073     }
80074   }
80075
80076 }
80077
80078
80079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
80080   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80081   unsigned int arg2 ;
80082   std::vector< Dali::Actor > *arg3 = 0 ;
80083
80084   arg1 = (Dali::Toolkit::TableView *)jarg1;
80085   arg2 = (unsigned int)jarg2;
80086   arg3 = (std::vector< Dali::Actor > *)jarg3;
80087   if (!arg3) {
80088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
80089     return ;
80090   }
80091   {
80092     try {
80093       (arg1)->DeleteColumn(arg2,*arg3);
80094     } catch (std::out_of_range& e) {
80095       {
80096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80097       };
80098     } catch (std::exception& e) {
80099       {
80100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80101       };
80102     } catch (Dali::DaliException e) {
80103       {
80104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80105       };
80106     } catch (...) {
80107       {
80108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80109       };
80110     }
80111   }
80112
80113 }
80114
80115
80116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
80117   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80118   unsigned int arg2 ;
80119   unsigned int arg3 ;
80120
80121   arg1 = (Dali::Toolkit::TableView *)jarg1;
80122   arg2 = (unsigned int)jarg2;
80123   arg3 = (unsigned int)jarg3;
80124   {
80125     try {
80126       (arg1)->Resize(arg2,arg3);
80127     } catch (std::out_of_range& e) {
80128       {
80129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80130       };
80131     } catch (std::exception& e) {
80132       {
80133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80134       };
80135     } catch (Dali::DaliException e) {
80136       {
80137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80138       };
80139     } catch (...) {
80140       {
80141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80142       };
80143     }
80144   }
80145
80146 }
80147
80148
80149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
80150   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80151   unsigned int arg2 ;
80152   unsigned int arg3 ;
80153   std::vector< Dali::Actor > *arg4 = 0 ;
80154
80155   arg1 = (Dali::Toolkit::TableView *)jarg1;
80156   arg2 = (unsigned int)jarg2;
80157   arg3 = (unsigned int)jarg3;
80158   arg4 = (std::vector< Dali::Actor > *)jarg4;
80159   if (!arg4) {
80160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
80161     return ;
80162   }
80163   {
80164     try {
80165       (arg1)->Resize(arg2,arg3,*arg4);
80166     } catch (std::out_of_range& e) {
80167       {
80168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80169       };
80170     } catch (std::exception& e) {
80171       {
80172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80173       };
80174     } catch (Dali::DaliException e) {
80175       {
80176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80177       };
80178     } catch (...) {
80179       {
80180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80181       };
80182     }
80183   }
80184
80185 }
80186
80187
80188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
80189   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80190   Dali::Size arg2 ;
80191   Dali::Size *argp2 ;
80192
80193   arg1 = (Dali::Toolkit::TableView *)jarg1;
80194   argp2 = (Dali::Size *)jarg2;
80195   if (!argp2) {
80196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
80197     return ;
80198   }
80199   arg2 = *argp2;
80200   {
80201     try {
80202       (arg1)->SetCellPadding(arg2);
80203     } catch (std::out_of_range& e) {
80204       {
80205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80206       };
80207     } catch (std::exception& e) {
80208       {
80209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80210       };
80211     } catch (Dali::DaliException e) {
80212       {
80213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80214       };
80215     } catch (...) {
80216       {
80217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80218       };
80219     }
80220   }
80221
80222 }
80223
80224
80225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
80226   void * jresult ;
80227   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80228   Dali::Size result;
80229
80230   arg1 = (Dali::Toolkit::TableView *)jarg1;
80231   {
80232     try {
80233       result = (arg1)->GetCellPadding();
80234     } catch (std::out_of_range& e) {
80235       {
80236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80237       };
80238     } catch (std::exception& e) {
80239       {
80240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80241       };
80242     } catch (Dali::DaliException e) {
80243       {
80244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80245       };
80246     } catch (...) {
80247       {
80248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80249       };
80250     }
80251   }
80252
80253   jresult = new Dali::Size((const Dali::Size &)result);
80254   return jresult;
80255 }
80256
80257
80258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
80259   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80260   unsigned int arg2 ;
80261
80262   arg1 = (Dali::Toolkit::TableView *)jarg1;
80263   arg2 = (unsigned int)jarg2;
80264   {
80265     try {
80266       (arg1)->SetFitHeight(arg2);
80267     } catch (std::out_of_range& e) {
80268       {
80269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80270       };
80271     } catch (std::exception& e) {
80272       {
80273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80274       };
80275     } catch (Dali::DaliException e) {
80276       {
80277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80278       };
80279     } catch (...) {
80280       {
80281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80282       };
80283     }
80284   }
80285
80286 }
80287
80288
80289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
80290   unsigned int jresult ;
80291   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80292   unsigned int arg2 ;
80293   bool result;
80294
80295   arg1 = (Dali::Toolkit::TableView *)jarg1;
80296   arg2 = (unsigned int)jarg2;
80297   {
80298     try {
80299       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
80300     } catch (std::out_of_range& e) {
80301       {
80302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80303       };
80304     } catch (std::exception& e) {
80305       {
80306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80307       };
80308     } catch (Dali::DaliException e) {
80309       {
80310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80311       };
80312     } catch (...) {
80313       {
80314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80315       };
80316     }
80317   }
80318
80319   jresult = result;
80320   return jresult;
80321 }
80322
80323
80324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
80325   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80326   unsigned int arg2 ;
80327
80328   arg1 = (Dali::Toolkit::TableView *)jarg1;
80329   arg2 = (unsigned int)jarg2;
80330   {
80331     try {
80332       (arg1)->SetFitWidth(arg2);
80333     } catch (std::out_of_range& e) {
80334       {
80335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80336       };
80337     } catch (std::exception& e) {
80338       {
80339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80340       };
80341     } catch (Dali::DaliException e) {
80342       {
80343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80344       };
80345     } catch (...) {
80346       {
80347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80348       };
80349     }
80350   }
80351
80352 }
80353
80354
80355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
80356   unsigned int jresult ;
80357   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80358   unsigned int arg2 ;
80359   bool result;
80360
80361   arg1 = (Dali::Toolkit::TableView *)jarg1;
80362   arg2 = (unsigned int)jarg2;
80363   {
80364     try {
80365       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
80366     } catch (std::out_of_range& e) {
80367       {
80368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80369       };
80370     } catch (std::exception& e) {
80371       {
80372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80373       };
80374     } catch (Dali::DaliException e) {
80375       {
80376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80377       };
80378     } catch (...) {
80379       {
80380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80381       };
80382     }
80383   }
80384
80385   jresult = result;
80386   return jresult;
80387 }
80388
80389
80390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
80391   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80392   unsigned int arg2 ;
80393   float arg3 ;
80394
80395   arg1 = (Dali::Toolkit::TableView *)jarg1;
80396   arg2 = (unsigned int)jarg2;
80397   arg3 = (float)jarg3;
80398   {
80399     try {
80400       (arg1)->SetFixedHeight(arg2,arg3);
80401     } catch (std::out_of_range& e) {
80402       {
80403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80404       };
80405     } catch (std::exception& e) {
80406       {
80407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80408       };
80409     } catch (Dali::DaliException e) {
80410       {
80411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80412       };
80413     } catch (...) {
80414       {
80415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80416       };
80417     }
80418   }
80419
80420 }
80421
80422
80423 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
80424   float jresult ;
80425   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80426   unsigned int arg2 ;
80427   float result;
80428
80429   arg1 = (Dali::Toolkit::TableView *)jarg1;
80430   arg2 = (unsigned int)jarg2;
80431   {
80432     try {
80433       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
80434     } catch (std::out_of_range& e) {
80435       {
80436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80437       };
80438     } catch (std::exception& e) {
80439       {
80440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80441       };
80442     } catch (Dali::DaliException e) {
80443       {
80444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80445       };
80446     } catch (...) {
80447       {
80448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80449       };
80450     }
80451   }
80452
80453   jresult = result;
80454   return jresult;
80455 }
80456
80457
80458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
80459   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80460   unsigned int arg2 ;
80461   float arg3 ;
80462
80463   arg1 = (Dali::Toolkit::TableView *)jarg1;
80464   arg2 = (unsigned int)jarg2;
80465   arg3 = (float)jarg3;
80466   {
80467     try {
80468       (arg1)->SetRelativeHeight(arg2,arg3);
80469     } catch (std::out_of_range& e) {
80470       {
80471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80472       };
80473     } catch (std::exception& e) {
80474       {
80475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80476       };
80477     } catch (Dali::DaliException e) {
80478       {
80479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80480       };
80481     } catch (...) {
80482       {
80483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80484       };
80485     }
80486   }
80487
80488 }
80489
80490
80491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
80492   float jresult ;
80493   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80494   unsigned int arg2 ;
80495   float result;
80496
80497   arg1 = (Dali::Toolkit::TableView *)jarg1;
80498   arg2 = (unsigned int)jarg2;
80499   {
80500     try {
80501       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
80502     } catch (std::out_of_range& e) {
80503       {
80504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80505       };
80506     } catch (std::exception& e) {
80507       {
80508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80509       };
80510     } catch (Dali::DaliException e) {
80511       {
80512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80513       };
80514     } catch (...) {
80515       {
80516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80517       };
80518     }
80519   }
80520
80521   jresult = result;
80522   return jresult;
80523 }
80524
80525
80526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
80527   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80528   unsigned int arg2 ;
80529   float arg3 ;
80530
80531   arg1 = (Dali::Toolkit::TableView *)jarg1;
80532   arg2 = (unsigned int)jarg2;
80533   arg3 = (float)jarg3;
80534   {
80535     try {
80536       (arg1)->SetFixedWidth(arg2,arg3);
80537     } catch (std::out_of_range& e) {
80538       {
80539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80540       };
80541     } catch (std::exception& e) {
80542       {
80543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80544       };
80545     } catch (Dali::DaliException e) {
80546       {
80547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80548       };
80549     } catch (...) {
80550       {
80551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80552       };
80553     }
80554   }
80555
80556 }
80557
80558
80559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
80560   float jresult ;
80561   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80562   unsigned int arg2 ;
80563   float result;
80564
80565   arg1 = (Dali::Toolkit::TableView *)jarg1;
80566   arg2 = (unsigned int)jarg2;
80567   {
80568     try {
80569       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
80570     } catch (std::out_of_range& e) {
80571       {
80572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80573       };
80574     } catch (std::exception& e) {
80575       {
80576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80577       };
80578     } catch (Dali::DaliException e) {
80579       {
80580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80581       };
80582     } catch (...) {
80583       {
80584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80585       };
80586     }
80587   }
80588
80589   jresult = result;
80590   return jresult;
80591 }
80592
80593
80594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
80595   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80596   unsigned int arg2 ;
80597   float arg3 ;
80598
80599   arg1 = (Dali::Toolkit::TableView *)jarg1;
80600   arg2 = (unsigned int)jarg2;
80601   arg3 = (float)jarg3;
80602   {
80603     try {
80604       (arg1)->SetRelativeWidth(arg2,arg3);
80605     } catch (std::out_of_range& e) {
80606       {
80607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80608       };
80609     } catch (std::exception& e) {
80610       {
80611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80612       };
80613     } catch (Dali::DaliException e) {
80614       {
80615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80616       };
80617     } catch (...) {
80618       {
80619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80620       };
80621     }
80622   }
80623
80624 }
80625
80626
80627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
80628   float jresult ;
80629   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80630   unsigned int arg2 ;
80631   float result;
80632
80633   arg1 = (Dali::Toolkit::TableView *)jarg1;
80634   arg2 = (unsigned int)jarg2;
80635   {
80636     try {
80637       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
80638     } catch (std::out_of_range& e) {
80639       {
80640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80641       };
80642     } catch (std::exception& e) {
80643       {
80644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80645       };
80646     } catch (Dali::DaliException e) {
80647       {
80648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80649       };
80650     } catch (...) {
80651       {
80652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80653       };
80654     }
80655   }
80656
80657   jresult = result;
80658   return jresult;
80659 }
80660
80661
80662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
80663   unsigned int jresult ;
80664   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80665   unsigned int result;
80666
80667   arg1 = (Dali::Toolkit::TableView *)jarg1;
80668   {
80669     try {
80670       result = (unsigned int)(arg1)->GetRows();
80671     } catch (std::out_of_range& e) {
80672       {
80673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80674       };
80675     } catch (std::exception& e) {
80676       {
80677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80678       };
80679     } catch (Dali::DaliException e) {
80680       {
80681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80682       };
80683     } catch (...) {
80684       {
80685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80686       };
80687     }
80688   }
80689
80690   jresult = result;
80691   return jresult;
80692 }
80693
80694
80695 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
80696   unsigned int jresult ;
80697   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80698   unsigned int result;
80699
80700   arg1 = (Dali::Toolkit::TableView *)jarg1;
80701   {
80702     try {
80703       result = (unsigned int)(arg1)->GetColumns();
80704     } catch (std::out_of_range& e) {
80705       {
80706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80707       };
80708     } catch (std::exception& e) {
80709       {
80710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80711       };
80712     } catch (Dali::DaliException e) {
80713       {
80714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80715       };
80716     } catch (...) {
80717       {
80718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80719       };
80720     }
80721   }
80722
80723   jresult = result;
80724   return jresult;
80725 }
80726
80727
80728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
80729   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80730   Dali::Toolkit::TableView::CellPosition arg2 ;
80731   Dali::HorizontalAlignment::Type arg3 ;
80732   Dali::VerticalAlignment::Type arg4 ;
80733   Dali::Toolkit::TableView::CellPosition *argp2 ;
80734
80735   arg1 = (Dali::Toolkit::TableView *)jarg1;
80736   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
80737   if (!argp2) {
80738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
80739     return ;
80740   }
80741   arg2 = *argp2;
80742   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
80743   arg4 = (Dali::VerticalAlignment::Type)jarg4;
80744   {
80745     try {
80746       (arg1)->SetCellAlignment(arg2,arg3,arg4);
80747     } catch (std::out_of_range& e) {
80748       {
80749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80750       };
80751     } catch (std::exception& e) {
80752       {
80753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80754       };
80755     } catch (Dali::DaliException e) {
80756       {
80757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80758       };
80759     } catch (...) {
80760       {
80761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80762       };
80763     }
80764   }
80765
80766 }
80767
80768
80769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
80770   unsigned int jresult ;
80771   unsigned int result;
80772
80773   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
80774   jresult = result;
80775   return jresult;
80776 }
80777
80778
80779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
80780   int jresult ;
80781   int result;
80782
80783   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
80784   jresult = (int)result;
80785   return jresult;
80786 }
80787
80788
80789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
80790   int jresult ;
80791   int result;
80792
80793   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
80794   jresult = (int)result;
80795   return jresult;
80796 }
80797
80798
80799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
80800   int jresult ;
80801   int result;
80802
80803   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
80804   jresult = (int)result;
80805   return jresult;
80806 }
80807
80808
80809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
80810   int jresult ;
80811   int result;
80812
80813   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
80814   jresult = (int)result;
80815   return jresult;
80816 }
80817
80818
80819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
80820   int jresult ;
80821   int result;
80822
80823   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
80824   jresult = (int)result;
80825   return jresult;
80826 }
80827
80828
80829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
80830   int jresult ;
80831   int result;
80832
80833   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
80834   jresult = (int)result;
80835   return jresult;
80836 }
80837
80838
80839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
80840   int jresult ;
80841   int result;
80842
80843   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
80844   jresult = (int)result;
80845   return jresult;
80846 }
80847
80848
80849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
80850   int jresult ;
80851   int result;
80852
80853   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
80854   jresult = (int)result;
80855   return jresult;
80856 }
80857
80858
80859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
80860   int jresult ;
80861   int result;
80862
80863   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
80864   jresult = (int)result;
80865   return jresult;
80866 }
80867
80868
80869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
80870   int jresult ;
80871   int result;
80872
80873   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
80874   jresult = (int)result;
80875   return jresult;
80876 }
80877
80878
80879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
80880   int jresult ;
80881   int result;
80882
80883   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
80884   jresult = (int)result;
80885   return jresult;
80886 }
80887
80888
80889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
80890   int jresult ;
80891   int result;
80892
80893   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
80894   jresult = (int)result;
80895   return jresult;
80896 }
80897
80898
80899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
80900   int jresult ;
80901   int result;
80902
80903   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
80904   jresult = (int)result;
80905   return jresult;
80906 }
80907
80908
80909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
80910   int jresult ;
80911   int result;
80912
80913   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
80914   jresult = (int)result;
80915   return jresult;
80916 }
80917
80918
80919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
80920   int jresult ;
80921   int result;
80922
80923   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
80924   jresult = (int)result;
80925   return jresult;
80926 }
80927
80928
80929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
80930   int jresult ;
80931   int result;
80932
80933   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
80934   jresult = (int)result;
80935   return jresult;
80936 }
80937
80938
80939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
80940   int jresult ;
80941   int result;
80942
80943   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
80944   jresult = (int)result;
80945   return jresult;
80946 }
80947
80948
80949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
80950   int jresult ;
80951   int result;
80952
80953   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
80954   jresult = (int)result;
80955   return jresult;
80956 }
80957
80958
80959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
80960   int jresult ;
80961   int result;
80962
80963   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
80964   jresult = (int)result;
80965   return jresult;
80966 }
80967
80968
80969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
80970   void * jresult ;
80971   Dali::Toolkit::TextLabel::Property *result = 0 ;
80972
80973   {
80974     try {
80975       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
80976     } catch (std::out_of_range& e) {
80977       {
80978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80979       };
80980     } catch (std::exception& e) {
80981       {
80982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80983       };
80984     } catch (Dali::DaliException e) {
80985       {
80986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80987       };
80988     } catch (...) {
80989       {
80990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80991       };
80992     }
80993   }
80994
80995   jresult = (void *)result;
80996   return jresult;
80997 }
80998
80999
81000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
81001   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
81002
81003   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
81004   {
81005     try {
81006       delete arg1;
81007     } catch (std::out_of_range& e) {
81008       {
81009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81010       };
81011     } catch (std::exception& e) {
81012       {
81013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81014       };
81015     } catch (Dali::DaliException e) {
81016       {
81017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81018       };
81019     } catch (...) {
81020       {
81021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81022       };
81023     }
81024   }
81025
81026 }
81027
81028
81029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
81030   void * jresult ;
81031   Dali::Toolkit::TextLabel result;
81032
81033   {
81034     try {
81035       result = Dali::Toolkit::TextLabel::New();
81036     } catch (std::out_of_range& e) {
81037       {
81038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81039       };
81040     } catch (std::exception& e) {
81041       {
81042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81043       };
81044     } catch (Dali::DaliException e) {
81045       {
81046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81047       };
81048     } catch (...) {
81049       {
81050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81051       };
81052     }
81053   }
81054
81055   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
81056   return jresult;
81057 }
81058
81059
81060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
81061   void * jresult ;
81062   std::string *arg1 = 0 ;
81063   Dali::Toolkit::TextLabel result;
81064
81065   if (!jarg1) {
81066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81067     return 0;
81068   }
81069   std::string arg1_str(jarg1);
81070   arg1 = &arg1_str;
81071   {
81072     try {
81073       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
81074     } catch (std::out_of_range& e) {
81075       {
81076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81077       };
81078     } catch (std::exception& e) {
81079       {
81080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81081       };
81082     } catch (Dali::DaliException e) {
81083       {
81084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81085       };
81086     } catch (...) {
81087       {
81088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81089       };
81090     }
81091   }
81092
81093   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
81094
81095   //argout typemap for const std::string&
81096
81097   return jresult;
81098 }
81099
81100
81101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
81102   void * jresult ;
81103   Dali::Toolkit::TextLabel *result = 0 ;
81104
81105   {
81106     try {
81107       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
81108     } catch (std::out_of_range& e) {
81109       {
81110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81111       };
81112     } catch (std::exception& e) {
81113       {
81114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81115       };
81116     } catch (Dali::DaliException e) {
81117       {
81118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81119       };
81120     } catch (...) {
81121       {
81122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81123       };
81124     }
81125   }
81126
81127   jresult = (void *)result;
81128   return jresult;
81129 }
81130
81131
81132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
81133   void * jresult ;
81134   Dali::Toolkit::TextLabel *arg1 = 0 ;
81135   Dali::Toolkit::TextLabel *result = 0 ;
81136
81137   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
81138   if (!arg1) {
81139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
81140     return 0;
81141   }
81142   {
81143     try {
81144       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
81145     } catch (std::out_of_range& e) {
81146       {
81147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81148       };
81149     } catch (std::exception& e) {
81150       {
81151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81152       };
81153     } catch (Dali::DaliException e) {
81154       {
81155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81156       };
81157     } catch (...) {
81158       {
81159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81160       };
81161     }
81162   }
81163
81164   jresult = (void *)result;
81165   return jresult;
81166 }
81167
81168
81169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
81170   void * jresult ;
81171   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
81172   Dali::Toolkit::TextLabel *arg2 = 0 ;
81173   Dali::Toolkit::TextLabel *result = 0 ;
81174
81175   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
81176   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
81177   if (!arg2) {
81178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
81179     return 0;
81180   }
81181   {
81182     try {
81183       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
81184     } catch (std::out_of_range& e) {
81185       {
81186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81187       };
81188     } catch (std::exception& e) {
81189       {
81190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81191       };
81192     } catch (Dali::DaliException e) {
81193       {
81194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81195       };
81196     } catch (...) {
81197       {
81198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81199       };
81200     }
81201   }
81202
81203   jresult = (void *)result;
81204   return jresult;
81205 }
81206
81207
81208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
81209   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
81210
81211   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
81212   {
81213     try {
81214       delete arg1;
81215     } catch (std::out_of_range& e) {
81216       {
81217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81218       };
81219     } catch (std::exception& e) {
81220       {
81221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81222       };
81223     } catch (Dali::DaliException e) {
81224       {
81225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81226       };
81227     } catch (...) {
81228       {
81229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81230       };
81231     }
81232   }
81233
81234 }
81235
81236
81237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
81238   void * jresult ;
81239   Dali::BaseHandle arg1 ;
81240   Dali::BaseHandle *argp1 ;
81241   Dali::Toolkit::TextLabel result;
81242
81243   argp1 = (Dali::BaseHandle *)jarg1;
81244   if (!argp1) {
81245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81246     return 0;
81247   }
81248   arg1 = *argp1;
81249   {
81250     try {
81251       result = Dali::Toolkit::TextLabel::DownCast(arg1);
81252     } catch (std::out_of_range& e) {
81253       {
81254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81255       };
81256     } catch (std::exception& e) {
81257       {
81258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81259       };
81260     } catch (Dali::DaliException e) {
81261       {
81262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81263       };
81264     } catch (...) {
81265       {
81266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81267       };
81268     }
81269   }
81270
81271   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
81272   return jresult;
81273 }
81274
81275
81276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
81277   void * jresult ;
81278   Dali::Toolkit::AccessibilityManager *result = 0 ;
81279
81280   {
81281     try {
81282       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
81283     } catch (std::out_of_range& e) {
81284       {
81285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81286       };
81287     } catch (std::exception& e) {
81288       {
81289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81290       };
81291     } catch (Dali::DaliException e) {
81292       {
81293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81294       };
81295     } catch (...) {
81296       {
81297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81298       };
81299     }
81300   }
81301
81302   jresult = (void *)result;
81303   return jresult;
81304 }
81305
81306
81307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
81308   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81309
81310   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81311   {
81312     try {
81313       delete arg1;
81314     } catch (std::out_of_range& e) {
81315       {
81316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81317       };
81318     } catch (std::exception& e) {
81319       {
81320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81321       };
81322     } catch (Dali::DaliException e) {
81323       {
81324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81325       };
81326     } catch (...) {
81327       {
81328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81329       };
81330     }
81331   }
81332
81333 }
81334
81335
81336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
81337   void * jresult ;
81338   Dali::Toolkit::AccessibilityManager result;
81339
81340   {
81341     try {
81342       result = Dali::Toolkit::AccessibilityManager::Get();
81343     } catch (std::out_of_range& e) {
81344       {
81345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81346       };
81347     } catch (std::exception& e) {
81348       {
81349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81350       };
81351     } catch (Dali::DaliException e) {
81352       {
81353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81354       };
81355     } catch (...) {
81356       {
81357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81358       };
81359     }
81360   }
81361
81362   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
81363   return jresult;
81364 }
81365
81366
81367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
81368   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81369   Dali::Actor arg2 ;
81370   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
81371   std::string *arg4 = 0 ;
81372   Dali::Actor *argp2 ;
81373
81374   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81375   argp2 = (Dali::Actor *)jarg2;
81376   if (!argp2) {
81377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81378     return ;
81379   }
81380   arg2 = *argp2;
81381   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
81382   if (!jarg4) {
81383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81384     return ;
81385   }
81386   std::string arg4_str(jarg4);
81387   arg4 = &arg4_str;
81388   {
81389     try {
81390       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
81391     } catch (std::out_of_range& e) {
81392       {
81393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81394       };
81395     } catch (std::exception& e) {
81396       {
81397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81398       };
81399     } catch (Dali::DaliException e) {
81400       {
81401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81402       };
81403     } catch (...) {
81404       {
81405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81406       };
81407     }
81408   }
81409
81410
81411   //argout typemap for const std::string&
81412
81413 }
81414
81415
81416 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
81417   char * jresult ;
81418   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81419   Dali::Actor arg2 ;
81420   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
81421   Dali::Actor *argp2 ;
81422   std::string result;
81423
81424   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81425   argp2 = (Dali::Actor *)jarg2;
81426   if (!argp2) {
81427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81428     return 0;
81429   }
81430   arg2 = *argp2;
81431   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
81432   {
81433     try {
81434       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
81435     } catch (std::out_of_range& e) {
81436       {
81437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81438       };
81439     } catch (std::exception& e) {
81440       {
81441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81442       };
81443     } catch (Dali::DaliException e) {
81444       {
81445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81446       };
81447     } catch (...) {
81448       {
81449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81450       };
81451     }
81452   }
81453
81454   jresult = SWIG_csharp_string_callback((&result)->c_str());
81455   return jresult;
81456 }
81457
81458
81459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
81460   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81461   Dali::Actor arg2 ;
81462   unsigned int arg3 ;
81463   Dali::Actor *argp2 ;
81464
81465   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81466   argp2 = (Dali::Actor *)jarg2;
81467   if (!argp2) {
81468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81469     return ;
81470   }
81471   arg2 = *argp2;
81472   arg3 = (unsigned int)jarg3;
81473   {
81474     try {
81475       (arg1)->SetFocusOrder(arg2,arg3);
81476     } catch (std::out_of_range& e) {
81477       {
81478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81479       };
81480     } catch (std::exception& e) {
81481       {
81482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81483       };
81484     } catch (Dali::DaliException e) {
81485       {
81486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81487       };
81488     } catch (...) {
81489       {
81490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81491       };
81492     }
81493   }
81494
81495 }
81496
81497
81498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
81499   unsigned int jresult ;
81500   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81501   Dali::Actor arg2 ;
81502   Dali::Actor *argp2 ;
81503   unsigned int result;
81504
81505   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81506   argp2 = (Dali::Actor *)jarg2;
81507   if (!argp2) {
81508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81509     return 0;
81510   }
81511   arg2 = *argp2;
81512   {
81513     try {
81514       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
81515     } catch (std::out_of_range& e) {
81516       {
81517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81518       };
81519     } catch (std::exception& e) {
81520       {
81521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81522       };
81523     } catch (Dali::DaliException e) {
81524       {
81525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81526       };
81527     } catch (...) {
81528       {
81529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81530       };
81531     }
81532   }
81533
81534   jresult = result;
81535   return jresult;
81536 }
81537
81538
81539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
81540   unsigned int jresult ;
81541   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81542   unsigned int result;
81543
81544   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81545   {
81546     try {
81547       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
81548     } catch (std::out_of_range& e) {
81549       {
81550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81551       };
81552     } catch (std::exception& e) {
81553       {
81554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81555       };
81556     } catch (Dali::DaliException e) {
81557       {
81558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81559       };
81560     } catch (...) {
81561       {
81562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81563       };
81564     }
81565   }
81566
81567   jresult = result;
81568   return jresult;
81569 }
81570
81571
81572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
81573   void * jresult ;
81574   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81575   unsigned int arg2 ;
81576   Dali::Actor result;
81577
81578   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81579   arg2 = (unsigned int)jarg2;
81580   {
81581     try {
81582       result = (arg1)->GetActorByFocusOrder(arg2);
81583     } catch (std::out_of_range& e) {
81584       {
81585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81586       };
81587     } catch (std::exception& e) {
81588       {
81589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81590       };
81591     } catch (Dali::DaliException e) {
81592       {
81593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81594       };
81595     } catch (...) {
81596       {
81597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81598       };
81599     }
81600   }
81601
81602   jresult = new Dali::Actor((const Dali::Actor &)result);
81603   return jresult;
81604 }
81605
81606
81607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
81608   unsigned int jresult ;
81609   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81610   Dali::Actor arg2 ;
81611   Dali::Actor *argp2 ;
81612   bool result;
81613
81614   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81615   argp2 = (Dali::Actor *)jarg2;
81616   if (!argp2) {
81617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81618     return 0;
81619   }
81620   arg2 = *argp2;
81621   {
81622     try {
81623       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
81624     } catch (std::out_of_range& e) {
81625       {
81626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81627       };
81628     } catch (std::exception& e) {
81629       {
81630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81631       };
81632     } catch (Dali::DaliException e) {
81633       {
81634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81635       };
81636     } catch (...) {
81637       {
81638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81639       };
81640     }
81641   }
81642
81643   jresult = result;
81644   return jresult;
81645 }
81646
81647
81648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
81649   void * jresult ;
81650   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81651   Dali::Actor result;
81652
81653   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81654   {
81655     try {
81656       result = (arg1)->GetCurrentFocusActor();
81657     } catch (std::out_of_range& e) {
81658       {
81659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81660       };
81661     } catch (std::exception& e) {
81662       {
81663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81664       };
81665     } catch (Dali::DaliException e) {
81666       {
81667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81668       };
81669     } catch (...) {
81670       {
81671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81672       };
81673     }
81674   }
81675
81676   jresult = new Dali::Actor((const Dali::Actor &)result);
81677   return jresult;
81678 }
81679
81680
81681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
81682   void * jresult ;
81683   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81684   Dali::Actor result;
81685
81686   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81687   {
81688     try {
81689       result = (arg1)->GetCurrentFocusGroup();
81690     } catch (std::out_of_range& e) {
81691       {
81692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81693       };
81694     } catch (std::exception& e) {
81695       {
81696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81697       };
81698     } catch (Dali::DaliException e) {
81699       {
81700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81701       };
81702     } catch (...) {
81703       {
81704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81705       };
81706     }
81707   }
81708
81709   jresult = new Dali::Actor((const Dali::Actor &)result);
81710   return jresult;
81711 }
81712
81713
81714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
81715   unsigned int jresult ;
81716   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81717   unsigned int result;
81718
81719   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81720   {
81721     try {
81722       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
81723     } catch (std::out_of_range& e) {
81724       {
81725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81726       };
81727     } catch (std::exception& e) {
81728       {
81729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81730       };
81731     } catch (Dali::DaliException e) {
81732       {
81733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81734       };
81735     } catch (...) {
81736       {
81737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81738       };
81739     }
81740   }
81741
81742   jresult = result;
81743   return jresult;
81744 }
81745
81746
81747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
81748   unsigned int jresult ;
81749   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81750   bool result;
81751
81752   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81753   {
81754     try {
81755       result = (bool)(arg1)->MoveFocusForward();
81756     } catch (std::out_of_range& e) {
81757       {
81758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81759       };
81760     } catch (std::exception& e) {
81761       {
81762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81763       };
81764     } catch (Dali::DaliException e) {
81765       {
81766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81767       };
81768     } catch (...) {
81769       {
81770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81771       };
81772     }
81773   }
81774
81775   jresult = result;
81776   return jresult;
81777 }
81778
81779
81780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
81781   unsigned int jresult ;
81782   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81783   bool result;
81784
81785   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81786   {
81787     try {
81788       result = (bool)(arg1)->MoveFocusBackward();
81789     } catch (std::out_of_range& e) {
81790       {
81791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81792       };
81793     } catch (std::exception& e) {
81794       {
81795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81796       };
81797     } catch (Dali::DaliException e) {
81798       {
81799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81800       };
81801     } catch (...) {
81802       {
81803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81804       };
81805     }
81806   }
81807
81808   jresult = result;
81809   return jresult;
81810 }
81811
81812
81813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
81814   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81815
81816   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81817   {
81818     try {
81819       (arg1)->ClearFocus();
81820     } catch (std::out_of_range& e) {
81821       {
81822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81823       };
81824     } catch (std::exception& e) {
81825       {
81826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81827       };
81828     } catch (Dali::DaliException e) {
81829       {
81830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81831       };
81832     } catch (...) {
81833       {
81834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81835       };
81836     }
81837   }
81838
81839 }
81840
81841
81842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
81843   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81844
81845   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81846   {
81847     try {
81848       (arg1)->Reset();
81849     } catch (std::out_of_range& e) {
81850       {
81851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81852       };
81853     } catch (std::exception& e) {
81854       {
81855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81856       };
81857     } catch (Dali::DaliException e) {
81858       {
81859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81860       };
81861     } catch (...) {
81862       {
81863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81864       };
81865     }
81866   }
81867
81868 }
81869
81870
81871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
81872   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81873   Dali::Actor arg2 ;
81874   bool arg3 ;
81875   Dali::Actor *argp2 ;
81876
81877   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81878   argp2 = (Dali::Actor *)jarg2;
81879   if (!argp2) {
81880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81881     return ;
81882   }
81883   arg2 = *argp2;
81884   arg3 = jarg3 ? true : false;
81885   {
81886     try {
81887       (arg1)->SetFocusGroup(arg2,arg3);
81888     } catch (std::out_of_range& e) {
81889       {
81890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81891       };
81892     } catch (std::exception& e) {
81893       {
81894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81895       };
81896     } catch (Dali::DaliException e) {
81897       {
81898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81899       };
81900     } catch (...) {
81901       {
81902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81903       };
81904     }
81905   }
81906
81907 }
81908
81909
81910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
81911   unsigned int jresult ;
81912   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81913   Dali::Actor arg2 ;
81914   Dali::Actor *argp2 ;
81915   bool result;
81916
81917   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81918   argp2 = (Dali::Actor *)jarg2;
81919   if (!argp2) {
81920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81921     return 0;
81922   }
81923   arg2 = *argp2;
81924   {
81925     try {
81926       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
81927     } catch (std::out_of_range& e) {
81928       {
81929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81930       };
81931     } catch (std::exception& e) {
81932       {
81933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81934       };
81935     } catch (Dali::DaliException e) {
81936       {
81937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81938       };
81939     } catch (...) {
81940       {
81941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81942       };
81943     }
81944   }
81945
81946   jresult = result;
81947   return jresult;
81948 }
81949
81950
81951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
81952   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81953   bool arg2 ;
81954
81955   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81956   arg2 = jarg2 ? true : false;
81957   {
81958     try {
81959       (arg1)->SetGroupMode(arg2);
81960     } catch (std::out_of_range& e) {
81961       {
81962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81963       };
81964     } catch (std::exception& e) {
81965       {
81966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81967       };
81968     } catch (Dali::DaliException e) {
81969       {
81970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81971       };
81972     } catch (...) {
81973       {
81974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81975       };
81976     }
81977   }
81978
81979 }
81980
81981
81982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
81983   unsigned int jresult ;
81984   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81985   bool result;
81986
81987   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81988   {
81989     try {
81990       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
81991     } catch (std::out_of_range& e) {
81992       {
81993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81994       };
81995     } catch (std::exception& e) {
81996       {
81997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81998       };
81999     } catch (Dali::DaliException e) {
82000       {
82001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82002       };
82003     } catch (...) {
82004       {
82005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82006       };
82007     }
82008   }
82009
82010   jresult = result;
82011   return jresult;
82012 }
82013
82014
82015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
82016   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82017   bool arg2 ;
82018
82019   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82020   arg2 = jarg2 ? true : false;
82021   {
82022     try {
82023       (arg1)->SetWrapMode(arg2);
82024     } catch (std::out_of_range& e) {
82025       {
82026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82027       };
82028     } catch (std::exception& e) {
82029       {
82030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82031       };
82032     } catch (Dali::DaliException e) {
82033       {
82034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82035       };
82036     } catch (...) {
82037       {
82038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82039       };
82040     }
82041   }
82042
82043 }
82044
82045
82046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
82047   unsigned int jresult ;
82048   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82049   bool result;
82050
82051   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82052   {
82053     try {
82054       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
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 = result;
82075   return jresult;
82076 }
82077
82078
82079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
82080   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82081   Dali::Actor arg2 ;
82082   Dali::Actor *argp2 ;
82083
82084   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82085   argp2 = (Dali::Actor *)jarg2;
82086   if (!argp2) {
82087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82088     return ;
82089   }
82090   arg2 = *argp2;
82091   {
82092     try {
82093       (arg1)->SetFocusIndicatorActor(arg2);
82094     } catch (std::out_of_range& e) {
82095       {
82096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82097       };
82098     } catch (std::exception& e) {
82099       {
82100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82101       };
82102     } catch (Dali::DaliException e) {
82103       {
82104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82105       };
82106     } catch (...) {
82107       {
82108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82109       };
82110     }
82111   }
82112
82113 }
82114
82115
82116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
82117   void * jresult ;
82118   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82119   Dali::Actor result;
82120
82121   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82122   {
82123     try {
82124       result = (arg1)->GetFocusIndicatorActor();
82125     } catch (std::out_of_range& e) {
82126       {
82127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82128       };
82129     } catch (std::exception& e) {
82130       {
82131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82132       };
82133     } catch (Dali::DaliException e) {
82134       {
82135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82136       };
82137     } catch (...) {
82138       {
82139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82140       };
82141     }
82142   }
82143
82144   jresult = new Dali::Actor((const Dali::Actor &)result);
82145   return jresult;
82146 }
82147
82148
82149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
82150   void * jresult ;
82151   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82152   Dali::Actor arg2 ;
82153   Dali::Actor *argp2 ;
82154   Dali::Actor result;
82155
82156   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82157   argp2 = (Dali::Actor *)jarg2;
82158   if (!argp2) {
82159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82160     return 0;
82161   }
82162   arg2 = *argp2;
82163   {
82164     try {
82165       result = (arg1)->GetFocusGroup(arg2);
82166     } catch (std::out_of_range& e) {
82167       {
82168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82169       };
82170     } catch (std::exception& e) {
82171       {
82172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82173       };
82174     } catch (Dali::DaliException e) {
82175       {
82176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82177       };
82178     } catch (...) {
82179       {
82180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82181       };
82182     }
82183   }
82184
82185   jresult = new Dali::Actor((const Dali::Actor &)result);
82186   return jresult;
82187 }
82188
82189
82190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
82191   void * jresult ;
82192   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82193   Dali::Vector2 result;
82194
82195   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82196   {
82197     try {
82198       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
82199     } catch (std::out_of_range& e) {
82200       {
82201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82202       };
82203     } catch (std::exception& e) {
82204       {
82205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82206       };
82207     } catch (Dali::DaliException e) {
82208       {
82209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82210       };
82211     } catch (...) {
82212       {
82213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82214       };
82215     }
82216   }
82217
82218   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
82219   return jresult;
82220 }
82221
82222
82223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
82224   void * jresult ;
82225   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82226   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
82227
82228   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82229   {
82230     try {
82231       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
82232     } catch (std::out_of_range& e) {
82233       {
82234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82235       };
82236     } catch (std::exception& e) {
82237       {
82238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82239       };
82240     } catch (Dali::DaliException e) {
82241       {
82242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82243       };
82244     } catch (...) {
82245       {
82246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82247       };
82248     }
82249   }
82250
82251   jresult = (void *)result;
82252   return jresult;
82253 }
82254
82255
82256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
82257   void * jresult ;
82258   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82259   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
82260
82261   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82262   {
82263     try {
82264       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
82265     } catch (std::out_of_range& e) {
82266       {
82267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82268       };
82269     } catch (std::exception& e) {
82270       {
82271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82272       };
82273     } catch (Dali::DaliException e) {
82274       {
82275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82276       };
82277     } catch (...) {
82278       {
82279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82280       };
82281     }
82282   }
82283
82284   jresult = (void *)result;
82285   return jresult;
82286 }
82287
82288
82289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
82290   void * jresult ;
82291   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82292   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
82293
82294   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82295   {
82296     try {
82297       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
82298     } catch (std::out_of_range& e) {
82299       {
82300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82301       };
82302     } catch (std::exception& e) {
82303       {
82304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82305       };
82306     } catch (Dali::DaliException e) {
82307       {
82308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82309       };
82310     } catch (...) {
82311       {
82312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82313       };
82314     }
82315   }
82316
82317   jresult = (void *)result;
82318   return jresult;
82319 }
82320
82321
82322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
82323   void * jresult ;
82324   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82325   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82326
82327   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82328   {
82329     try {
82330       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
82331     } catch (std::out_of_range& e) {
82332       {
82333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82334       };
82335     } catch (std::exception& e) {
82336       {
82337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82338       };
82339     } catch (Dali::DaliException e) {
82340       {
82341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82342       };
82343     } catch (...) {
82344       {
82345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82346       };
82347     }
82348   }
82349
82350   jresult = (void *)result;
82351   return jresult;
82352 }
82353
82354
82355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
82356   void * jresult ;
82357   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82358   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82359
82360   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82361   {
82362     try {
82363       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
82364     } catch (std::out_of_range& e) {
82365       {
82366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82367       };
82368     } catch (std::exception& e) {
82369       {
82370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82371       };
82372     } catch (Dali::DaliException e) {
82373       {
82374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82375       };
82376     } catch (...) {
82377       {
82378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82379       };
82380     }
82381   }
82382
82383   jresult = (void *)result;
82384   return jresult;
82385 }
82386
82387
82388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
82389   void * jresult ;
82390   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82391   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82392
82393   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82394   {
82395     try {
82396       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
82397     } catch (std::out_of_range& e) {
82398       {
82399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82400       };
82401     } catch (std::exception& e) {
82402       {
82403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82404       };
82405     } catch (Dali::DaliException e) {
82406       {
82407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82408       };
82409     } catch (...) {
82410       {
82411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82412       };
82413     }
82414   }
82415
82416   jresult = (void *)result;
82417   return jresult;
82418 }
82419
82420
82421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
82422   void * jresult ;
82423   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82424   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82425
82426   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82427   {
82428     try {
82429       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
82430     } catch (std::out_of_range& e) {
82431       {
82432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82433       };
82434     } catch (std::exception& e) {
82435       {
82436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82437       };
82438     } catch (Dali::DaliException e) {
82439       {
82440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82441       };
82442     } catch (...) {
82443       {
82444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82445       };
82446     }
82447   }
82448
82449   jresult = (void *)result;
82450   return jresult;
82451 }
82452
82453
82454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
82455   void * jresult ;
82456   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82457   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82458
82459   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82460   {
82461     try {
82462       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
82463     } catch (std::out_of_range& e) {
82464       {
82465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82466       };
82467     } catch (std::exception& e) {
82468       {
82469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82470       };
82471     } catch (Dali::DaliException e) {
82472       {
82473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82474       };
82475     } catch (...) {
82476       {
82477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82478       };
82479     }
82480   }
82481
82482   jresult = (void *)result;
82483   return jresult;
82484 }
82485
82486
82487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
82488   void * jresult ;
82489   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82490   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82491
82492   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82493   {
82494     try {
82495       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
82496     } catch (std::out_of_range& e) {
82497       {
82498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82499       };
82500     } catch (std::exception& e) {
82501       {
82502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82503       };
82504     } catch (Dali::DaliException e) {
82505       {
82506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82507       };
82508     } catch (...) {
82509       {
82510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82511       };
82512     }
82513   }
82514
82515   jresult = (void *)result;
82516   return jresult;
82517 }
82518
82519
82520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
82521   void * jresult ;
82522   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82523   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82524
82525   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82526   {
82527     try {
82528       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
82529     } catch (std::out_of_range& e) {
82530       {
82531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82532       };
82533     } catch (std::exception& e) {
82534       {
82535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82536       };
82537     } catch (Dali::DaliException e) {
82538       {
82539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82540       };
82541     } catch (...) {
82542       {
82543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82544       };
82545     }
82546   }
82547
82548   jresult = (void *)result;
82549   return jresult;
82550 }
82551
82552
82553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
82554   void * jresult ;
82555   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82556   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82557
82558   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82559   {
82560     try {
82561       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
82562     } catch (std::out_of_range& e) {
82563       {
82564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82565       };
82566     } catch (std::exception& e) {
82567       {
82568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82569       };
82570     } catch (Dali::DaliException e) {
82571       {
82572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82573       };
82574     } catch (...) {
82575       {
82576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82577       };
82578     }
82579   }
82580
82581   jresult = (void *)result;
82582   return jresult;
82583 }
82584
82585
82586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
82587   void * jresult ;
82588   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82589   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82590
82591   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82592   {
82593     try {
82594       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
82595     } catch (std::out_of_range& e) {
82596       {
82597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82598       };
82599     } catch (std::exception& e) {
82600       {
82601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82602       };
82603     } catch (Dali::DaliException e) {
82604       {
82605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82606       };
82607     } catch (...) {
82608       {
82609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82610       };
82611     }
82612   }
82613
82614   jresult = (void *)result;
82615   return jresult;
82616 }
82617
82618
82619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
82620   void * jresult ;
82621   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82622   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82623
82624   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82625   {
82626     try {
82627       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
82628     } catch (std::out_of_range& e) {
82629       {
82630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82631       };
82632     } catch (std::exception& e) {
82633       {
82634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82635       };
82636     } catch (Dali::DaliException e) {
82637       {
82638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82639       };
82640     } catch (...) {
82641       {
82642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82643       };
82644     }
82645   }
82646
82647   jresult = (void *)result;
82648   return jresult;
82649 }
82650
82651
82652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
82653   void * jresult ;
82654   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82655   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82656
82657   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82658   {
82659     try {
82660       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
82661     } catch (std::out_of_range& e) {
82662       {
82663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82664       };
82665     } catch (std::exception& e) {
82666       {
82667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82668       };
82669     } catch (Dali::DaliException e) {
82670       {
82671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82672       };
82673     } catch (...) {
82674       {
82675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82676       };
82677     }
82678   }
82679
82680   jresult = (void *)result;
82681   return jresult;
82682 }
82683
82684
82685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
82686   void * jresult ;
82687   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82688   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82689
82690   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82691   {
82692     try {
82693       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
82694     } catch (std::out_of_range& e) {
82695       {
82696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82697       };
82698     } catch (std::exception& e) {
82699       {
82700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82701       };
82702     } catch (Dali::DaliException e) {
82703       {
82704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82705       };
82706     } catch (...) {
82707       {
82708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82709       };
82710     }
82711   }
82712
82713   jresult = (void *)result;
82714   return jresult;
82715 }
82716
82717
82718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
82719   void * jresult ;
82720   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82721   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82722
82723   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82724   {
82725     try {
82726       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
82727     } catch (std::out_of_range& e) {
82728       {
82729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82730       };
82731     } catch (std::exception& e) {
82732       {
82733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82734       };
82735     } catch (Dali::DaliException e) {
82736       {
82737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82738       };
82739     } catch (...) {
82740       {
82741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82742       };
82743     }
82744   }
82745
82746   jresult = (void *)result;
82747   return jresult;
82748 }
82749
82750
82751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
82752   void * jresult ;
82753   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82754   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82755
82756   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82757   {
82758     try {
82759       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
82760     } catch (std::out_of_range& e) {
82761       {
82762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82763       };
82764     } catch (std::exception& e) {
82765       {
82766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82767       };
82768     } catch (Dali::DaliException e) {
82769       {
82770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82771       };
82772     } catch (...) {
82773       {
82774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82775       };
82776     }
82777   }
82778
82779   jresult = (void *)result;
82780   return jresult;
82781 }
82782
82783
82784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
82785   void * jresult ;
82786   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82787   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82788
82789   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82790   {
82791     try {
82792       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
82793     } catch (std::out_of_range& e) {
82794       {
82795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82796       };
82797     } catch (std::exception& e) {
82798       {
82799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82800       };
82801     } catch (Dali::DaliException e) {
82802       {
82803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82804       };
82805     } catch (...) {
82806       {
82807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82808       };
82809     }
82810   }
82811
82812   jresult = (void *)result;
82813   return jresult;
82814 }
82815
82816
82817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
82818   void * jresult ;
82819   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82820   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82821
82822   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82823   {
82824     try {
82825       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
82826     } catch (std::out_of_range& e) {
82827       {
82828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82829       };
82830     } catch (std::exception& e) {
82831       {
82832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82833       };
82834     } catch (Dali::DaliException e) {
82835       {
82836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82837       };
82838     } catch (...) {
82839       {
82840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82841       };
82842     }
82843   }
82844
82845   jresult = (void *)result;
82846   return jresult;
82847 }
82848
82849
82850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
82851   void * jresult ;
82852   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82853   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82854
82855   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82856   {
82857     try {
82858       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
82859     } catch (std::out_of_range& e) {
82860       {
82861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82862       };
82863     } catch (std::exception& e) {
82864       {
82865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82866       };
82867     } catch (Dali::DaliException e) {
82868       {
82869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82870       };
82871     } catch (...) {
82872       {
82873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82874       };
82875     }
82876   }
82877
82878   jresult = (void *)result;
82879   return jresult;
82880 }
82881
82882
82883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
82884   void * jresult ;
82885   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82886   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82887
82888   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82889   {
82890     try {
82891       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
82892     } catch (std::out_of_range& e) {
82893       {
82894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82895       };
82896     } catch (std::exception& e) {
82897       {
82898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82899       };
82900     } catch (Dali::DaliException e) {
82901       {
82902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82903       };
82904     } catch (...) {
82905       {
82906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82907       };
82908     }
82909   }
82910
82911   jresult = (void *)result;
82912   return jresult;
82913 }
82914
82915
82916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
82917   void * jresult ;
82918   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82919   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82920
82921   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82922   {
82923     try {
82924       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
82925     } catch (std::out_of_range& e) {
82926       {
82927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82928       };
82929     } catch (std::exception& e) {
82930       {
82931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82932       };
82933     } catch (Dali::DaliException e) {
82934       {
82935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82936       };
82937     } catch (...) {
82938       {
82939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82940       };
82941     }
82942   }
82943
82944   jresult = (void *)result;
82945   return jresult;
82946 }
82947
82948
82949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
82950   void * jresult ;
82951   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82952   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82953
82954   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82955   {
82956     try {
82957       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
82958     } catch (std::out_of_range& e) {
82959       {
82960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82961       };
82962     } catch (std::exception& e) {
82963       {
82964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82965       };
82966     } catch (Dali::DaliException e) {
82967       {
82968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82969       };
82970     } catch (...) {
82971       {
82972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82973       };
82974     }
82975   }
82976
82977   jresult = (void *)result;
82978   return jresult;
82979 }
82980
82981
82982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
82983   void * jresult ;
82984   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82985   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82986
82987   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82988   {
82989     try {
82990       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
82991     } catch (std::out_of_range& e) {
82992       {
82993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82994       };
82995     } catch (std::exception& e) {
82996       {
82997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82998       };
82999     } catch (Dali::DaliException e) {
83000       {
83001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83002       };
83003     } catch (...) {
83004       {
83005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83006       };
83007     }
83008   }
83009
83010   jresult = (void *)result;
83011   return jresult;
83012 }
83013
83014
83015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
83016   void * jresult ;
83017   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83018   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83019
83020   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83021   {
83022     try {
83023       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
83024     } catch (std::out_of_range& e) {
83025       {
83026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83027       };
83028     } catch (std::exception& e) {
83029       {
83030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83031       };
83032     } catch (Dali::DaliException e) {
83033       {
83034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83035       };
83036     } catch (...) {
83037       {
83038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83039       };
83040     }
83041   }
83042
83043   jresult = (void *)result;
83044   return jresult;
83045 }
83046
83047
83048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
83049   void * jresult ;
83050   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83051   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83052
83053   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83054   {
83055     try {
83056       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
83057     } catch (std::out_of_range& e) {
83058       {
83059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83060       };
83061     } catch (std::exception& e) {
83062       {
83063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83064       };
83065     } catch (Dali::DaliException e) {
83066       {
83067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83068       };
83069     } catch (...) {
83070       {
83071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83072       };
83073     }
83074   }
83075
83076   jresult = (void *)result;
83077   return jresult;
83078 }
83079
83080
83081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
83082   void * jresult ;
83083   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83084   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83085
83086   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83087   {
83088     try {
83089       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
83090     } catch (std::out_of_range& e) {
83091       {
83092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83093       };
83094     } catch (std::exception& e) {
83095       {
83096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83097       };
83098     } catch (Dali::DaliException e) {
83099       {
83100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83101       };
83102     } catch (...) {
83103       {
83104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83105       };
83106     }
83107   }
83108
83109   jresult = (void *)result;
83110   return jresult;
83111 }
83112
83113
83114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
83115   void * jresult ;
83116   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83117   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83118
83119   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83120   {
83121     try {
83122       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
83123     } catch (std::out_of_range& e) {
83124       {
83125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83126       };
83127     } catch (std::exception& e) {
83128       {
83129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83130       };
83131     } catch (Dali::DaliException e) {
83132       {
83133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83134       };
83135     } catch (...) {
83136       {
83137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83138       };
83139     }
83140   }
83141
83142   jresult = (void *)result;
83143   return jresult;
83144 }
83145
83146
83147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
83148   void * jresult ;
83149   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83150   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83151
83152   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83153   {
83154     try {
83155       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
83156     } catch (std::out_of_range& e) {
83157       {
83158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83159       };
83160     } catch (std::exception& e) {
83161       {
83162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83163       };
83164     } catch (Dali::DaliException e) {
83165       {
83166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83167       };
83168     } catch (...) {
83169       {
83170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83171       };
83172     }
83173   }
83174
83175   jresult = (void *)result;
83176   return jresult;
83177 }
83178
83179
83180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
83181   void * jresult ;
83182   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83183   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
83184
83185   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83186   {
83187     try {
83188       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
83189     } catch (std::out_of_range& e) {
83190       {
83191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83192       };
83193     } catch (std::exception& e) {
83194       {
83195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83196       };
83197     } catch (Dali::DaliException e) {
83198       {
83199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83200       };
83201     } catch (...) {
83202       {
83203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83204       };
83205     }
83206   }
83207
83208   jresult = (void *)result;
83209   return jresult;
83210 }
83211
83212
83213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
83214   void * jresult ;
83215   Dali::Toolkit::StyleManager *result = 0 ;
83216
83217   {
83218     try {
83219       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
83220     } catch (std::out_of_range& e) {
83221       {
83222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83223       };
83224     } catch (std::exception& e) {
83225       {
83226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83227       };
83228     } catch (Dali::DaliException e) {
83229       {
83230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83231       };
83232     } catch (...) {
83233       {
83234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83235       };
83236     }
83237   }
83238
83239   jresult = (void *)result;
83240   return jresult;
83241 }
83242
83243
83244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
83245   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83246
83247   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
83248   {
83249     try {
83250       delete arg1;
83251     } catch (std::out_of_range& e) {
83252       {
83253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83254       };
83255     } catch (std::exception& e) {
83256       {
83257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83258       };
83259     } catch (Dali::DaliException e) {
83260       {
83261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83262       };
83263     } catch (...) {
83264       {
83265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83266       };
83267     }
83268   }
83269
83270 }
83271
83272
83273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
83274   void * jresult ;
83275   Dali::Toolkit::StyleManager result;
83276
83277   {
83278     try {
83279       result = Dali::Toolkit::StyleManager::Get();
83280     } catch (std::out_of_range& e) {
83281       {
83282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83283       };
83284     } catch (std::exception& e) {
83285       {
83286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83287       };
83288     } catch (Dali::DaliException e) {
83289       {
83290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83291       };
83292     } catch (...) {
83293       {
83294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83295       };
83296     }
83297   }
83298
83299   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
83300   return jresult;
83301 }
83302
83303
83304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
83305   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83306   std::string *arg2 = 0 ;
83307
83308   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
83309   if (!jarg2) {
83310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83311     return ;
83312   }
83313   std::string arg2_str(jarg2);
83314   arg2 = &arg2_str;
83315   {
83316     try {
83317       (arg1)->ApplyTheme((std::string const &)*arg2);
83318     } catch (std::out_of_range& e) {
83319       {
83320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83321       };
83322     } catch (std::exception& e) {
83323       {
83324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83325       };
83326     } catch (Dali::DaliException e) {
83327       {
83328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83329       };
83330     } catch (...) {
83331       {
83332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83333       };
83334     }
83335   }
83336
83337
83338   //argout typemap for const std::string&
83339
83340 }
83341
83342
83343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
83344   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83345
83346   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
83347   {
83348     try {
83349       (arg1)->ApplyDefaultTheme();
83350     } catch (std::out_of_range& e) {
83351       {
83352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83353       };
83354     } catch (std::exception& e) {
83355       {
83356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83357       };
83358     } catch (Dali::DaliException e) {
83359       {
83360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83361       };
83362     } catch (...) {
83363       {
83364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83365       };
83366     }
83367   }
83368
83369 }
83370
83371
83372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
83373   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83374   std::string *arg2 = 0 ;
83375   Dali::Property::Value *arg3 = 0 ;
83376
83377   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
83378   if (!jarg2) {
83379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83380     return ;
83381   }
83382   std::string arg2_str(jarg2);
83383   arg2 = &arg2_str;
83384   arg3 = (Dali::Property::Value *)jarg3;
83385   if (!arg3) {
83386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
83387     return ;
83388   }
83389   {
83390     try {
83391       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
83392     } catch (std::out_of_range& e) {
83393       {
83394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83395       };
83396     } catch (std::exception& e) {
83397       {
83398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83399       };
83400     } catch (Dali::DaliException e) {
83401       {
83402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83403       };
83404     } catch (...) {
83405       {
83406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83407       };
83408     }
83409   }
83410
83411
83412   //argout typemap for const std::string&
83413
83414 }
83415
83416
83417 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
83418   unsigned int jresult ;
83419   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83420   std::string *arg2 = 0 ;
83421   Dali::Property::Value *arg3 = 0 ;
83422   bool result;
83423
83424   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
83425   if (!jarg2) {
83426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83427     return 0;
83428   }
83429   std::string arg2_str(jarg2);
83430   arg2 = &arg2_str;
83431   arg3 = (Dali::Property::Value *)jarg3;
83432   if (!arg3) {
83433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
83434     return 0;
83435   }
83436   {
83437     try {
83438       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
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 = result;
83459
83460   //argout typemap for const std::string&
83461
83462   return jresult;
83463 }
83464
83465
83466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
83467   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83468   Dali::Toolkit::Control arg2 ;
83469   std::string *arg3 = 0 ;
83470   std::string *arg4 = 0 ;
83471   Dali::Toolkit::Control *argp2 ;
83472
83473   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
83474   argp2 = (Dali::Toolkit::Control *)jarg2;
83475   if (!argp2) {
83476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
83477     return ;
83478   }
83479   arg2 = *argp2;
83480   if (!jarg3) {
83481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83482     return ;
83483   }
83484   std::string arg3_str(jarg3);
83485   arg3 = &arg3_str;
83486   if (!jarg4) {
83487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83488     return ;
83489   }
83490   std::string arg4_str(jarg4);
83491   arg4 = &arg4_str;
83492   {
83493     try {
83494       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
83495     } catch (std::out_of_range& e) {
83496       {
83497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83498       };
83499     } catch (std::exception& e) {
83500       {
83501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83502       };
83503     } catch (Dali::DaliException e) {
83504       {
83505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83506       };
83507     } catch (...) {
83508       {
83509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83510       };
83511     }
83512   }
83513
83514
83515   //argout typemap for const std::string&
83516
83517
83518   //argout typemap for const std::string&
83519
83520 }
83521
83522
83523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
83524   void * jresult ;
83525   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83526   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
83527
83528   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
83529   {
83530     try {
83531       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
83532     } catch (std::out_of_range& e) {
83533       {
83534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83535       };
83536     } catch (std::exception& e) {
83537       {
83538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83539       };
83540     } catch (Dali::DaliException e) {
83541       {
83542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83543       };
83544     } catch (...) {
83545       {
83546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83547       };
83548     }
83549   }
83550
83551   jresult = (void *)result;
83552   return jresult;
83553 }
83554
83555
83556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
83557   int jresult ;
83558   int result;
83559
83560   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
83561   jresult = (int)result;
83562   return jresult;
83563 }
83564
83565
83566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
83567   int jresult ;
83568   int result;
83569
83570   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
83571   jresult = (int)result;
83572   return jresult;
83573 }
83574
83575
83576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
83577   int jresult ;
83578   int result;
83579
83580   result = (int)Dali::Toolkit::Slider::Property::VALUE;
83581   jresult = (int)result;
83582   return jresult;
83583 }
83584
83585
83586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
83587   int jresult ;
83588   int result;
83589
83590   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
83591   jresult = (int)result;
83592   return jresult;
83593 }
83594
83595
83596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
83597   int jresult ;
83598   int result;
83599
83600   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
83601   jresult = (int)result;
83602   return jresult;
83603 }
83604
83605
83606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
83607   int jresult ;
83608   int result;
83609
83610   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
83611   jresult = (int)result;
83612   return jresult;
83613 }
83614
83615
83616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
83617   int jresult ;
83618   int result;
83619
83620   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
83621   jresult = (int)result;
83622   return jresult;
83623 }
83624
83625
83626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
83627   int jresult ;
83628   int result;
83629
83630   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
83631   jresult = (int)result;
83632   return jresult;
83633 }
83634
83635
83636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
83637   int jresult ;
83638   int result;
83639
83640   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
83641   jresult = (int)result;
83642   return jresult;
83643 }
83644
83645
83646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
83647   int jresult ;
83648   int result;
83649
83650   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
83651   jresult = (int)result;
83652   return jresult;
83653 }
83654
83655
83656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
83657   int jresult ;
83658   int result;
83659
83660   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
83661   jresult = (int)result;
83662   return jresult;
83663 }
83664
83665
83666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
83667   int jresult ;
83668   int result;
83669
83670   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
83671   jresult = (int)result;
83672   return jresult;
83673 }
83674
83675
83676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
83677   int jresult ;
83678   int result;
83679
83680   result = (int)Dali::Toolkit::Slider::Property::MARKS;
83681   jresult = (int)result;
83682   return jresult;
83683 }
83684
83685
83686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
83687   int jresult ;
83688   int result;
83689
83690   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
83691   jresult = (int)result;
83692   return jresult;
83693 }
83694
83695
83696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
83697   int jresult ;
83698   int result;
83699
83700   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
83701   jresult = (int)result;
83702   return jresult;
83703 }
83704
83705
83706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
83707   void * jresult ;
83708   Dali::Toolkit::Slider::Property *result = 0 ;
83709
83710   {
83711     try {
83712       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
83713     } catch (std::out_of_range& e) {
83714       {
83715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83716       };
83717     } catch (std::exception& e) {
83718       {
83719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83720       };
83721     } catch (Dali::DaliException e) {
83722       {
83723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83724       };
83725     } catch (...) {
83726       {
83727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83728       };
83729     }
83730   }
83731
83732   jresult = (void *)result;
83733   return jresult;
83734 }
83735
83736
83737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
83738   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
83739
83740   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
83741   {
83742     try {
83743       delete arg1;
83744     } catch (std::out_of_range& e) {
83745       {
83746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83747       };
83748     } catch (std::exception& e) {
83749       {
83750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83751       };
83752     } catch (Dali::DaliException e) {
83753       {
83754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83755       };
83756     } catch (...) {
83757       {
83758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83759       };
83760     }
83761   }
83762
83763 }
83764
83765
83766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
83767   void * jresult ;
83768   Dali::Toolkit::Slider result;
83769
83770   {
83771     try {
83772       result = Dali::Toolkit::Slider::New();
83773     } catch (std::out_of_range& e) {
83774       {
83775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83776       };
83777     } catch (std::exception& e) {
83778       {
83779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83780       };
83781     } catch (Dali::DaliException e) {
83782       {
83783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83784       };
83785     } catch (...) {
83786       {
83787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83788       };
83789     }
83790   }
83791
83792   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
83793   return jresult;
83794 }
83795
83796
83797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
83798   void * jresult ;
83799   Dali::Toolkit::Slider *result = 0 ;
83800
83801   {
83802     try {
83803       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
83804     } catch (std::out_of_range& e) {
83805       {
83806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83807       };
83808     } catch (std::exception& e) {
83809       {
83810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83811       };
83812     } catch (Dali::DaliException e) {
83813       {
83814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83815       };
83816     } catch (...) {
83817       {
83818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83819       };
83820     }
83821   }
83822
83823   jresult = (void *)result;
83824   return jresult;
83825 }
83826
83827
83828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
83829   void * jresult ;
83830   Dali::Toolkit::Slider *arg1 = 0 ;
83831   Dali::Toolkit::Slider *result = 0 ;
83832
83833   arg1 = (Dali::Toolkit::Slider *)jarg1;
83834   if (!arg1) {
83835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
83836     return 0;
83837   }
83838   {
83839     try {
83840       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
83841     } catch (std::out_of_range& e) {
83842       {
83843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83844       };
83845     } catch (std::exception& e) {
83846       {
83847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83848       };
83849     } catch (Dali::DaliException e) {
83850       {
83851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83852       };
83853     } catch (...) {
83854       {
83855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83856       };
83857     }
83858   }
83859
83860   jresult = (void *)result;
83861   return jresult;
83862 }
83863
83864
83865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
83866   void * jresult ;
83867   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
83868   Dali::Toolkit::Slider *arg2 = 0 ;
83869   Dali::Toolkit::Slider *result = 0 ;
83870
83871   arg1 = (Dali::Toolkit::Slider *)jarg1;
83872   arg2 = (Dali::Toolkit::Slider *)jarg2;
83873   if (!arg2) {
83874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
83875     return 0;
83876   }
83877   {
83878     try {
83879       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
83880     } catch (std::out_of_range& e) {
83881       {
83882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83883       };
83884     } catch (std::exception& e) {
83885       {
83886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83887       };
83888     } catch (Dali::DaliException e) {
83889       {
83890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83891       };
83892     } catch (...) {
83893       {
83894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83895       };
83896     }
83897   }
83898
83899   jresult = (void *)result;
83900   return jresult;
83901 }
83902
83903
83904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
83905   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
83906
83907   arg1 = (Dali::Toolkit::Slider *)jarg1;
83908   {
83909     try {
83910       delete arg1;
83911     } catch (std::out_of_range& e) {
83912       {
83913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83914       };
83915     } catch (std::exception& e) {
83916       {
83917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83918       };
83919     } catch (Dali::DaliException e) {
83920       {
83921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83922       };
83923     } catch (...) {
83924       {
83925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83926       };
83927     }
83928   }
83929
83930 }
83931
83932
83933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
83934   void * jresult ;
83935   Dali::BaseHandle arg1 ;
83936   Dali::BaseHandle *argp1 ;
83937   Dali::Toolkit::Slider result;
83938
83939   argp1 = (Dali::BaseHandle *)jarg1;
83940   if (!argp1) {
83941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83942     return 0;
83943   }
83944   arg1 = *argp1;
83945   {
83946     try {
83947       result = Dali::Toolkit::Slider::DownCast(arg1);
83948     } catch (std::out_of_range& e) {
83949       {
83950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83951       };
83952     } catch (std::exception& e) {
83953       {
83954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83955       };
83956     } catch (Dali::DaliException e) {
83957       {
83958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83959       };
83960     } catch (...) {
83961       {
83962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83963       };
83964     }
83965   }
83966
83967   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
83968   return jresult;
83969 }
83970
83971
83972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
83973   void * jresult ;
83974   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
83975   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
83976
83977   arg1 = (Dali::Toolkit::Slider *)jarg1;
83978   {
83979     try {
83980       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83981     } catch (std::out_of_range& e) {
83982       {
83983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83984       };
83985     } catch (std::exception& e) {
83986       {
83987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83988       };
83989     } catch (Dali::DaliException e) {
83990       {
83991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83992       };
83993     } catch (...) {
83994       {
83995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83996       };
83997     }
83998   }
83999
84000   jresult = (void *)result;
84001   return jresult;
84002 }
84003
84004
84005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
84006   void * jresult ;
84007   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
84008   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
84009
84010   arg1 = (Dali::Toolkit::Slider *)jarg1;
84011   {
84012     try {
84013       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
84014     } catch (std::out_of_range& e) {
84015       {
84016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84017       };
84018     } catch (std::exception& e) {
84019       {
84020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84021       };
84022     } catch (Dali::DaliException e) {
84023       {
84024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84025       };
84026     } catch (...) {
84027       {
84028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84029       };
84030     }
84031   }
84032
84033   jresult = (void *)result;
84034   return jresult;
84035 }
84036
84037
84038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
84039   void * jresult ;
84040   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
84041   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
84042
84043   arg1 = (Dali::Toolkit::Slider *)jarg1;
84044   {
84045     try {
84046       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
84047     } catch (std::out_of_range& e) {
84048       {
84049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84050       };
84051     } catch (std::exception& e) {
84052       {
84053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84054       };
84055     } catch (Dali::DaliException e) {
84056       {
84057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84058       };
84059     } catch (...) {
84060       {
84061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84062       };
84063     }
84064   }
84065
84066   jresult = (void *)result;
84067   return jresult;
84068 }
84069
84070
84071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
84072   int jresult ;
84073   int result;
84074
84075   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
84076   jresult = (int)result;
84077   return jresult;
84078 }
84079
84080
84081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
84082   int jresult ;
84083   int result;
84084
84085   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
84086   jresult = (int)result;
84087   return jresult;
84088 }
84089
84090
84091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
84092   int jresult ;
84093   int result;
84094
84095   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
84096   jresult = (int)result;
84097   return jresult;
84098 }
84099
84100
84101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
84102   int jresult ;
84103   int result;
84104
84105   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
84106   jresult = (int)result;
84107   return jresult;
84108 }
84109
84110
84111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
84112   int result;
84113
84114   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
84115
84116   return result;
84117 }
84118
84119
84120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
84121   void * jresult ;
84122   Dali::Toolkit::VideoView::Property *result = 0 ;
84123
84124   {
84125     try {
84126       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
84127     } catch (std::out_of_range& e) {
84128       {
84129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84130       };
84131     } catch (std::exception& e) {
84132       {
84133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84134       };
84135     } catch (Dali::DaliException e) {
84136       {
84137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84138       };
84139     } catch (...) {
84140       {
84141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84142       };
84143     }
84144   }
84145
84146   jresult = (void *)result;
84147   return jresult;
84148 }
84149
84150
84151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
84152   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
84153
84154   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
84155   {
84156     try {
84157       delete arg1;
84158     } catch (std::out_of_range& e) {
84159       {
84160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84161       };
84162     } catch (std::exception& e) {
84163       {
84164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84165       };
84166     } catch (Dali::DaliException e) {
84167       {
84168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84169       };
84170     } catch (...) {
84171       {
84172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84173       };
84174     }
84175   }
84176
84177 }
84178
84179
84180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
84181   void * jresult ;
84182   Dali::Toolkit::VideoView result;
84183
84184   {
84185     try {
84186       result = Dali::Toolkit::VideoView::New();
84187     } catch (std::out_of_range& e) {
84188       {
84189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84190       };
84191     } catch (std::exception& e) {
84192       {
84193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84194       };
84195     } catch (Dali::DaliException e) {
84196       {
84197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84198       };
84199     } catch (...) {
84200       {
84201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84202       };
84203     }
84204   }
84205
84206   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
84207   return jresult;
84208 }
84209
84210
84211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
84212   void * jresult ;
84213   std::string *arg1 = 0 ;
84214   Dali::Toolkit::VideoView result;
84215
84216   if (!jarg1) {
84217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84218     return 0;
84219   }
84220   std::string arg1_str(jarg1);
84221   arg1 = &arg1_str;
84222   {
84223     try {
84224       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
84225     } catch (std::out_of_range& e) {
84226       {
84227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84228       };
84229     } catch (std::exception& e) {
84230       {
84231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84232       };
84233     } catch (Dali::DaliException e) {
84234       {
84235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84236       };
84237     } catch (...) {
84238       {
84239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84240       };
84241     }
84242   }
84243
84244   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
84245
84246   //argout typemap for const std::string&
84247
84248   return jresult;
84249 }
84250
84251
84252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
84253   void * jresult ;
84254   Dali::Toolkit::VideoView result;
84255   {
84256     try {
84257       result = Dali::Toolkit::VideoView::New(swCodec);
84258     } catch (std::out_of_range& e) {
84259       {
84260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84261       };
84262     } catch (std::exception& e) {
84263       {
84264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84265       };
84266     } catch (Dali::DaliException e) {
84267       {
84268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84269       };
84270     } catch (...) {
84271       {
84272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84273       };
84274     }
84275   }
84276
84277   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
84278
84279   //argout typemap for const std::string&
84280
84281   return jresult;
84282 }
84283
84284
84285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
84286   void * jresult ;
84287   std::string *arg1 = 0 ;
84288   Dali::Toolkit::VideoView result;
84289
84290   if (!jarg1) {
84291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84292     return 0;
84293   }
84294   std::string arg1_str(jarg1);
84295   arg1 = &arg1_str;
84296   {
84297     try {
84298       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
84299     } catch (std::out_of_range& e) {
84300       {
84301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84302       };
84303     } catch (std::exception& e) {
84304       {
84305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84306       };
84307     } catch (Dali::DaliException e) {
84308       {
84309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84310       };
84311     } catch (...) {
84312       {
84313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84314       };
84315     }
84316   }
84317
84318   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
84319
84320   //argout typemap for const std::string&
84321
84322   return jresult;
84323 }
84324
84325
84326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
84327   void * jresult ;
84328   Dali::Toolkit::VideoView *result = 0 ;
84329
84330   {
84331     try {
84332       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
84333     } catch (std::out_of_range& e) {
84334       {
84335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84336       };
84337     } catch (std::exception& e) {
84338       {
84339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84340       };
84341     } catch (Dali::DaliException e) {
84342       {
84343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84344       };
84345     } catch (...) {
84346       {
84347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84348       };
84349     }
84350   }
84351
84352   jresult = (void *)result;
84353   return jresult;
84354 }
84355
84356
84357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
84358   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
84359
84360   arg1 = (Dali::Toolkit::VideoView *)jarg1;
84361   {
84362     try {
84363       delete arg1;
84364     } catch (std::out_of_range& e) {
84365       {
84366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84367       };
84368     } catch (std::exception& e) {
84369       {
84370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84371       };
84372     } catch (Dali::DaliException e) {
84373       {
84374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84375       };
84376     } catch (...) {
84377       {
84378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84379       };
84380     }
84381   }
84382
84383 }
84384
84385
84386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
84387   void * jresult ;
84388   Dali::Toolkit::VideoView *arg1 = 0 ;
84389   Dali::Toolkit::VideoView *result = 0 ;
84390
84391   arg1 = (Dali::Toolkit::VideoView *)jarg1;
84392   if (!arg1) {
84393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
84394     return 0;
84395   }
84396   {
84397     try {
84398       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
84399     } catch (std::out_of_range& e) {
84400       {
84401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84402       };
84403     } catch (std::exception& e) {
84404       {
84405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84406       };
84407     } catch (Dali::DaliException e) {
84408       {
84409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84410       };
84411     } catch (...) {
84412       {
84413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84414       };
84415     }
84416   }
84417
84418   jresult = (void *)result;
84419   return jresult;
84420 }
84421
84422
84423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
84424   void * jresult ;
84425   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
84426   Dali::Toolkit::VideoView *arg2 = 0 ;
84427   Dali::Toolkit::VideoView *result = 0 ;
84428
84429   arg1 = (Dali::Toolkit::VideoView *)jarg1;
84430   arg2 = (Dali::Toolkit::VideoView *)jarg2;
84431   if (!arg2) {
84432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
84433     return 0;
84434   }
84435   {
84436     try {
84437       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
84438     } catch (std::out_of_range& e) {
84439       {
84440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84441       };
84442     } catch (std::exception& e) {
84443       {
84444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84445       };
84446     } catch (Dali::DaliException e) {
84447       {
84448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84449       };
84450     } catch (...) {
84451       {
84452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84453       };
84454     }
84455   }
84456
84457   jresult = (void *)result;
84458   return jresult;
84459 }
84460
84461
84462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
84463   void * jresult ;
84464   Dali::BaseHandle arg1 ;
84465   Dali::BaseHandle *argp1 ;
84466   Dali::Toolkit::VideoView result;
84467
84468   argp1 = (Dali::BaseHandle *)jarg1;
84469   if (!argp1) {
84470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84471     return 0;
84472   }
84473   arg1 = *argp1;
84474   {
84475     try {
84476       result = Dali::Toolkit::VideoView::DownCast(arg1);
84477     } catch (std::out_of_range& e) {
84478       {
84479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (std::exception& e) {
84482       {
84483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84484       };
84485     } catch (Dali::DaliException e) {
84486       {
84487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84488       };
84489     } catch (...) {
84490       {
84491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84492       };
84493     }
84494   }
84495
84496   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
84497   return jresult;
84498 }
84499
84500
84501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
84502   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
84503
84504   arg1 = (Dali::Toolkit::VideoView *)jarg1;
84505   {
84506     try {
84507       (arg1)->Play();
84508     } catch (std::out_of_range& e) {
84509       {
84510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84511       };
84512     } catch (std::exception& e) {
84513       {
84514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84515       };
84516     } catch (Dali::DaliException e) {
84517       {
84518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84519       };
84520     } catch (...) {
84521       {
84522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84523       };
84524     }
84525   }
84526
84527 }
84528
84529
84530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
84531   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
84532
84533   arg1 = (Dali::Toolkit::VideoView *)jarg1;
84534   {
84535     try {
84536       (arg1)->Pause();
84537     } catch (std::out_of_range& e) {
84538       {
84539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84540       };
84541     } catch (std::exception& e) {
84542       {
84543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84544       };
84545     } catch (Dali::DaliException e) {
84546       {
84547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84548       };
84549     } catch (...) {
84550       {
84551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84552       };
84553     }
84554   }
84555
84556 }
84557
84558
84559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
84560   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
84561
84562   arg1 = (Dali::Toolkit::VideoView *)jarg1;
84563   {
84564     try {
84565       (arg1)->Stop();
84566     } catch (std::out_of_range& e) {
84567       {
84568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84569       };
84570     } catch (std::exception& e) {
84571       {
84572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84573       };
84574     } catch (Dali::DaliException e) {
84575       {
84576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84577       };
84578     } catch (...) {
84579       {
84580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84581       };
84582     }
84583   }
84584
84585 }
84586
84587
84588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
84589   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
84590   int arg2 ;
84591
84592   arg1 = (Dali::Toolkit::VideoView *)jarg1;
84593   arg2 = (int)jarg2;
84594   {
84595     try {
84596       (arg1)->Forward(arg2);
84597     } catch (std::out_of_range& e) {
84598       {
84599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84600       };
84601     } catch (std::exception& e) {
84602       {
84603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84604       };
84605     } catch (Dali::DaliException e) {
84606       {
84607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84608       };
84609     } catch (...) {
84610       {
84611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84612       };
84613     }
84614   }
84615
84616 }
84617
84618
84619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
84620   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
84621   int arg2 ;
84622
84623   arg1 = (Dali::Toolkit::VideoView *)jarg1;
84624   arg2 = (int)jarg2;
84625   {
84626     try {
84627       (arg1)->Backward(arg2);
84628     } catch (std::out_of_range& e) {
84629       {
84630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84631       };
84632     } catch (std::exception& e) {
84633       {
84634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84635       };
84636     } catch (Dali::DaliException e) {
84637       {
84638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84639       };
84640     } catch (...) {
84641       {
84642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84643       };
84644     }
84645   }
84646
84647 }
84648
84649
84650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
84651   void * jresult ;
84652   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
84653   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
84654
84655   arg1 = (Dali::Toolkit::VideoView *)jarg1;
84656   {
84657     try {
84658       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
84659     } catch (std::out_of_range& e) {
84660       {
84661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84662       };
84663     } catch (std::exception& e) {
84664       {
84665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84666       };
84667     } catch (Dali::DaliException e) {
84668       {
84669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84670       };
84671     } catch (...) {
84672       {
84673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84674       };
84675     }
84676   }
84677
84678   jresult = (void *)result;
84679   return jresult;
84680 }
84681
84682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
84683 {
84684   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
84685   if( arg1 == nullptr )
84686   {
84687     DALI_LOG_ERROR("VideoView is nullptr!");
84688     return nullptr;
84689   }
84690   void * ret = nullptr;
84691   {
84692     try{
84693
84694       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
84695       ret = Dali::AnyCast< void * >( result );
84696
84697     } catch (std::out_of_range& e) {
84698       {
84699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84700       };
84701     } catch (std::exception& e) {
84702       {
84703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84704       };
84705     } catch (Dali::DaliException e) {
84706       {
84707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84708       };
84709     } catch (...) {
84710       {
84711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84712       };
84713     }
84714   }
84715   return ret;
84716 }
84717
84718
84719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
84720   int jresult ;
84721   int result;
84722
84723   result = (int)Dali::Toolkit::Popup::Property::TITLE;
84724   jresult = (int)result;
84725   return jresult;
84726 }
84727
84728
84729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
84730   int jresult ;
84731   int result;
84732
84733   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
84734   jresult = (int)result;
84735   return jresult;
84736 }
84737
84738
84739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
84740   int jresult ;
84741   int result;
84742
84743   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
84744   jresult = (int)result;
84745   return jresult;
84746 }
84747
84748
84749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
84750   int jresult ;
84751   int result;
84752
84753   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
84754   jresult = (int)result;
84755   return jresult;
84756 }
84757
84758
84759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
84760   int jresult ;
84761   int result;
84762
84763   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
84764   jresult = (int)result;
84765   return jresult;
84766 }
84767
84768
84769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
84770   int jresult ;
84771   int result;
84772
84773   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
84774   jresult = (int)result;
84775   return jresult;
84776 }
84777
84778
84779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
84780   int jresult ;
84781   int result;
84782
84783   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
84784   jresult = (int)result;
84785   return jresult;
84786 }
84787
84788
84789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
84790   int jresult ;
84791   int result;
84792
84793   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
84794   jresult = (int)result;
84795   return jresult;
84796 }
84797
84798
84799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
84800   int jresult ;
84801   int result;
84802
84803   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
84804   jresult = (int)result;
84805   return jresult;
84806 }
84807
84808
84809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
84810   int jresult ;
84811   int result;
84812
84813   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
84814   jresult = (int)result;
84815   return jresult;
84816 }
84817
84818
84819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
84820   int jresult ;
84821   int result;
84822
84823   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
84824   jresult = (int)result;
84825   return jresult;
84826 }
84827
84828
84829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
84830   int jresult ;
84831   int result;
84832
84833   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
84834   jresult = (int)result;
84835   return jresult;
84836 }
84837
84838
84839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
84840   int jresult ;
84841   int result;
84842
84843   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
84844   jresult = (int)result;
84845   return jresult;
84846 }
84847
84848
84849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
84850   int jresult ;
84851   int result;
84852
84853   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
84854   jresult = (int)result;
84855   return jresult;
84856 }
84857
84858
84859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
84860   int jresult ;
84861   int result;
84862
84863   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
84864   jresult = (int)result;
84865   return jresult;
84866 }
84867
84868
84869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
84870   int jresult ;
84871   int result;
84872
84873   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
84874   jresult = (int)result;
84875   return jresult;
84876 }
84877
84878
84879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
84880   int jresult ;
84881   int result;
84882
84883   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
84884   jresult = (int)result;
84885   return jresult;
84886 }
84887
84888
84889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
84890   int jresult ;
84891   int result;
84892
84893   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
84894   jresult = (int)result;
84895   return jresult;
84896 }
84897
84898
84899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
84900   int jresult ;
84901   int result;
84902
84903   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
84904   jresult = (int)result;
84905   return jresult;
84906 }
84907
84908
84909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
84910   int jresult ;
84911   int result;
84912
84913   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
84914   jresult = (int)result;
84915   return jresult;
84916 }
84917
84918
84919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
84920   int jresult ;
84921   int result;
84922
84923   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
84924   jresult = (int)result;
84925   return jresult;
84926 }
84927
84928
84929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
84930   void * jresult ;
84931   Dali::Toolkit::Popup::Property *result = 0 ;
84932
84933   {
84934     try {
84935       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
84936     } catch (std::out_of_range& e) {
84937       {
84938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84939       };
84940     } catch (std::exception& e) {
84941       {
84942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84943       };
84944     } catch (Dali::DaliException e) {
84945       {
84946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84947       };
84948     } catch (...) {
84949       {
84950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84951       };
84952     }
84953   }
84954
84955   jresult = (void *)result;
84956   return jresult;
84957 }
84958
84959
84960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
84961   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
84962
84963   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
84964   {
84965     try {
84966       delete arg1;
84967     } catch (std::out_of_range& e) {
84968       {
84969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84970       };
84971     } catch (std::exception& e) {
84972       {
84973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84974       };
84975     } catch (Dali::DaliException e) {
84976       {
84977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84978       };
84979     } catch (...) {
84980       {
84981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84982       };
84983     }
84984   }
84985
84986 }
84987
84988
84989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
84990   void * jresult ;
84991   Dali::Toolkit::Popup *result = 0 ;
84992
84993   {
84994     try {
84995       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
84996     } catch (std::out_of_range& e) {
84997       {
84998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84999       };
85000     } catch (std::exception& e) {
85001       {
85002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85003       };
85004     } catch (Dali::DaliException e) {
85005       {
85006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85007       };
85008     } catch (...) {
85009       {
85010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85011       };
85012     }
85013   }
85014
85015   jresult = (void *)result;
85016   return jresult;
85017 }
85018
85019
85020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
85021   void * jresult ;
85022   Dali::Toolkit::Popup result;
85023
85024   {
85025     try {
85026       result = Dali::Toolkit::Popup::New();
85027     } catch (std::out_of_range& e) {
85028       {
85029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85030       };
85031     } catch (std::exception& e) {
85032       {
85033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85034       };
85035     } catch (Dali::DaliException e) {
85036       {
85037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85038       };
85039     } catch (...) {
85040       {
85041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85042       };
85043     }
85044   }
85045
85046   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
85047   return jresult;
85048 }
85049
85050
85051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
85052   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85053
85054   arg1 = (Dali::Toolkit::Popup *)jarg1;
85055   {
85056     try {
85057       delete arg1;
85058     } catch (std::out_of_range& e) {
85059       {
85060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85061       };
85062     } catch (std::exception& e) {
85063       {
85064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85065       };
85066     } catch (Dali::DaliException e) {
85067       {
85068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85069       };
85070     } catch (...) {
85071       {
85072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85073       };
85074     }
85075   }
85076
85077 }
85078
85079
85080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
85081   void * jresult ;
85082   Dali::Toolkit::Popup *arg1 = 0 ;
85083   Dali::Toolkit::Popup *result = 0 ;
85084
85085   arg1 = (Dali::Toolkit::Popup *)jarg1;
85086   if (!arg1) {
85087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
85088     return 0;
85089   }
85090   {
85091     try {
85092       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
85093     } catch (std::out_of_range& e) {
85094       {
85095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85096       };
85097     } catch (std::exception& e) {
85098       {
85099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85100       };
85101     } catch (Dali::DaliException e) {
85102       {
85103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85104       };
85105     } catch (...) {
85106       {
85107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85108       };
85109     }
85110   }
85111
85112   jresult = (void *)result;
85113   return jresult;
85114 }
85115
85116
85117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
85118   void * jresult ;
85119   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85120   Dali::Toolkit::Popup *arg2 = 0 ;
85121   Dali::Toolkit::Popup *result = 0 ;
85122
85123   arg1 = (Dali::Toolkit::Popup *)jarg1;
85124   arg2 = (Dali::Toolkit::Popup *)jarg2;
85125   if (!arg2) {
85126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
85127     return 0;
85128   }
85129   {
85130     try {
85131       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
85132     } catch (std::out_of_range& e) {
85133       {
85134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85135       };
85136     } catch (std::exception& e) {
85137       {
85138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85139       };
85140     } catch (Dali::DaliException e) {
85141       {
85142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85143       };
85144     } catch (...) {
85145       {
85146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85147       };
85148     }
85149   }
85150
85151   jresult = (void *)result;
85152   return jresult;
85153 }
85154
85155
85156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
85157   void * jresult ;
85158   Dali::BaseHandle arg1 ;
85159   Dali::BaseHandle *argp1 ;
85160   Dali::Toolkit::Popup result;
85161
85162   argp1 = (Dali::BaseHandle *)jarg1;
85163   if (!argp1) {
85164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85165     return 0;
85166   }
85167   arg1 = *argp1;
85168   {
85169     try {
85170       result = Dali::Toolkit::Popup::DownCast(arg1);
85171     } catch (std::out_of_range& e) {
85172       {
85173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85174       };
85175     } catch (std::exception& e) {
85176       {
85177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85178       };
85179     } catch (Dali::DaliException e) {
85180       {
85181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85182       };
85183     } catch (...) {
85184       {
85185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85186       };
85187     }
85188   }
85189
85190   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
85191   return jresult;
85192 }
85193
85194
85195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
85196   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85197   Dali::Actor arg2 ;
85198   Dali::Actor *argp2 ;
85199
85200   arg1 = (Dali::Toolkit::Popup *)jarg1;
85201   argp2 = (Dali::Actor *)jarg2;
85202   if (!argp2) {
85203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85204     return ;
85205   }
85206   arg2 = *argp2;
85207   {
85208     try {
85209       (arg1)->SetTitle(arg2);
85210     } catch (std::out_of_range& e) {
85211       {
85212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85213       };
85214     } catch (std::exception& e) {
85215       {
85216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85217       };
85218     } catch (Dali::DaliException e) {
85219       {
85220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85221       };
85222     } catch (...) {
85223       {
85224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85225       };
85226     }
85227   }
85228
85229 }
85230
85231
85232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
85233   void * jresult ;
85234   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85235   Dali::Actor result;
85236
85237   arg1 = (Dali::Toolkit::Popup *)jarg1;
85238   {
85239     try {
85240       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
85241     } catch (std::out_of_range& e) {
85242       {
85243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85244       };
85245     } catch (std::exception& e) {
85246       {
85247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85248       };
85249     } catch (Dali::DaliException e) {
85250       {
85251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85252       };
85253     } catch (...) {
85254       {
85255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85256       };
85257     }
85258   }
85259
85260   jresult = new Dali::Actor((const Dali::Actor &)result);
85261   return jresult;
85262 }
85263
85264
85265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
85266   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85267   Dali::Actor arg2 ;
85268   Dali::Actor *argp2 ;
85269
85270   arg1 = (Dali::Toolkit::Popup *)jarg1;
85271   argp2 = (Dali::Actor *)jarg2;
85272   if (!argp2) {
85273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85274     return ;
85275   }
85276   arg2 = *argp2;
85277   {
85278     try {
85279       (arg1)->SetContent(arg2);
85280     } catch (std::out_of_range& e) {
85281       {
85282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85283       };
85284     } catch (std::exception& e) {
85285       {
85286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85287       };
85288     } catch (Dali::DaliException e) {
85289       {
85290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85291       };
85292     } catch (...) {
85293       {
85294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85295       };
85296     }
85297   }
85298
85299 }
85300
85301
85302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
85303   void * jresult ;
85304   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85305   Dali::Actor result;
85306
85307   arg1 = (Dali::Toolkit::Popup *)jarg1;
85308   {
85309     try {
85310       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
85311     } catch (std::out_of_range& e) {
85312       {
85313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85314       };
85315     } catch (std::exception& e) {
85316       {
85317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85318       };
85319     } catch (Dali::DaliException e) {
85320       {
85321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85322       };
85323     } catch (...) {
85324       {
85325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85326       };
85327     }
85328   }
85329
85330   jresult = new Dali::Actor((const Dali::Actor &)result);
85331   return jresult;
85332 }
85333
85334
85335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
85336   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85337   Dali::Actor arg2 ;
85338   Dali::Actor *argp2 ;
85339
85340   arg1 = (Dali::Toolkit::Popup *)jarg1;
85341   argp2 = (Dali::Actor *)jarg2;
85342   if (!argp2) {
85343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85344     return ;
85345   }
85346   arg2 = *argp2;
85347   {
85348     try {
85349       (arg1)->SetFooter(arg2);
85350     } catch (std::out_of_range& e) {
85351       {
85352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85353       };
85354     } catch (std::exception& e) {
85355       {
85356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85357       };
85358     } catch (Dali::DaliException e) {
85359       {
85360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85361       };
85362     } catch (...) {
85363       {
85364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85365       };
85366     }
85367   }
85368
85369 }
85370
85371
85372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
85373   void * jresult ;
85374   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85375   Dali::Actor result;
85376
85377   arg1 = (Dali::Toolkit::Popup *)jarg1;
85378   {
85379     try {
85380       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
85381     } catch (std::out_of_range& e) {
85382       {
85383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85384       };
85385     } catch (std::exception& e) {
85386       {
85387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85388       };
85389     } catch (Dali::DaliException e) {
85390       {
85391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85392       };
85393     } catch (...) {
85394       {
85395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85396       };
85397     }
85398   }
85399
85400   jresult = new Dali::Actor((const Dali::Actor &)result);
85401   return jresult;
85402 }
85403
85404
85405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
85406   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85407   Dali::Toolkit::Popup::DisplayState arg2 ;
85408
85409   arg1 = (Dali::Toolkit::Popup *)jarg1;
85410   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
85411   {
85412     try {
85413       (arg1)->SetDisplayState(arg2);
85414     } catch (std::out_of_range& e) {
85415       {
85416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85417       };
85418     } catch (std::exception& e) {
85419       {
85420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85421       };
85422     } catch (Dali::DaliException e) {
85423       {
85424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85425       };
85426     } catch (...) {
85427       {
85428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85429       };
85430     }
85431   }
85432
85433 }
85434
85435
85436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
85437   int jresult ;
85438   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85439   Dali::Toolkit::Popup::DisplayState result;
85440
85441   arg1 = (Dali::Toolkit::Popup *)jarg1;
85442   {
85443     try {
85444       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
85445     } catch (std::out_of_range& e) {
85446       {
85447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85448       };
85449     } catch (std::exception& e) {
85450       {
85451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85452       };
85453     } catch (Dali::DaliException e) {
85454       {
85455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85456       };
85457     } catch (...) {
85458       {
85459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85460       };
85461     }
85462   }
85463
85464   jresult = (int)result;
85465   return jresult;
85466 }
85467
85468
85469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
85470   void * jresult ;
85471   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85472   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
85473
85474   arg1 = (Dali::Toolkit::Popup *)jarg1;
85475   {
85476     try {
85477       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
85478     } catch (std::out_of_range& e) {
85479       {
85480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85481       };
85482     } catch (std::exception& e) {
85483       {
85484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85485       };
85486     } catch (Dali::DaliException e) {
85487       {
85488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85489       };
85490     } catch (...) {
85491       {
85492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85493       };
85494     }
85495   }
85496
85497   jresult = (void *)result;
85498   return jresult;
85499 }
85500
85501
85502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
85503   void * jresult ;
85504   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85505   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
85506
85507   arg1 = (Dali::Toolkit::Popup *)jarg1;
85508   {
85509     try {
85510       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
85511     } catch (std::out_of_range& e) {
85512       {
85513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85514       };
85515     } catch (std::exception& e) {
85516       {
85517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85518       };
85519     } catch (Dali::DaliException e) {
85520       {
85521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85522       };
85523     } catch (...) {
85524       {
85525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85526       };
85527     }
85528   }
85529
85530   jresult = (void *)result;
85531   return jresult;
85532 }
85533
85534
85535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
85536   void * jresult ;
85537   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85538   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
85539
85540   arg1 = (Dali::Toolkit::Popup *)jarg1;
85541   {
85542     try {
85543       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
85544     } catch (std::out_of_range& e) {
85545       {
85546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85547       };
85548     } catch (std::exception& e) {
85549       {
85550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85551       };
85552     } catch (Dali::DaliException e) {
85553       {
85554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85555       };
85556     } catch (...) {
85557       {
85558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85559       };
85560     }
85561   }
85562
85563   jresult = (void *)result;
85564   return jresult;
85565 }
85566
85567
85568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
85569   void * jresult ;
85570   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85571   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
85572
85573   arg1 = (Dali::Toolkit::Popup *)jarg1;
85574   {
85575     try {
85576       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
85577     } catch (std::out_of_range& e) {
85578       {
85579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85580       };
85581     } catch (std::exception& e) {
85582       {
85583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85584       };
85585     } catch (Dali::DaliException e) {
85586       {
85587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85588       };
85589     } catch (...) {
85590       {
85591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85592       };
85593     }
85594   }
85595
85596   jresult = (void *)result;
85597   return jresult;
85598 }
85599
85600
85601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
85602   void * jresult ;
85603   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85604   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
85605
85606   arg1 = (Dali::Toolkit::Popup *)jarg1;
85607   {
85608     try {
85609       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
85610     } catch (std::out_of_range& e) {
85611       {
85612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85613       };
85614     } catch (std::exception& e) {
85615       {
85616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85617       };
85618     } catch (Dali::DaliException e) {
85619       {
85620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85621       };
85622     } catch (...) {
85623       {
85624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85625       };
85626     }
85627   }
85628
85629   jresult = (void *)result;
85630   return jresult;
85631 }
85632
85633
85634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
85635   int jresult ;
85636   int result;
85637
85638   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
85639   jresult = (int)result;
85640   return jresult;
85641 }
85642
85643
85644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
85645   int jresult ;
85646   int result;
85647
85648   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
85649   jresult = (int)result;
85650   return jresult;
85651 }
85652
85653
85654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
85655   int jresult ;
85656   int result;
85657
85658   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
85659   jresult = (int)result;
85660   return jresult;
85661 }
85662
85663
85664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
85665   int jresult ;
85666   int result;
85667
85668   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
85669   jresult = (int)result;
85670   return jresult;
85671 }
85672
85673
85674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
85675   int jresult ;
85676   int result;
85677
85678   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
85679   jresult = (int)result;
85680   return jresult;
85681 }
85682
85683
85684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
85685   int jresult ;
85686   int result;
85687
85688   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
85689   jresult = (int)result;
85690   return jresult;
85691 }
85692
85693
85694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
85695   int jresult ;
85696   int result;
85697
85698   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
85699   jresult = (int)result;
85700   return jresult;
85701 }
85702
85703
85704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
85705   int jresult ;
85706   int result;
85707
85708   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
85709   jresult = (int)result;
85710   return jresult;
85711 }
85712
85713
85714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
85715   int jresult ;
85716   int result;
85717
85718   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
85719   jresult = (int)result;
85720   return jresult;
85721 }
85722
85723
85724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
85725   void * jresult ;
85726   Dali::Toolkit::ProgressBar::Property *result = 0 ;
85727
85728   {
85729     try {
85730       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
85731     } catch (std::out_of_range& e) {
85732       {
85733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85734       };
85735     } catch (std::exception& e) {
85736       {
85737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85738       };
85739     } catch (Dali::DaliException e) {
85740       {
85741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85742       };
85743     } catch (...) {
85744       {
85745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85746       };
85747     }
85748   }
85749
85750   jresult = (void *)result;
85751   return jresult;
85752 }
85753
85754
85755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
85756   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
85757
85758   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
85759   {
85760     try {
85761       delete arg1;
85762     } catch (std::out_of_range& e) {
85763       {
85764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85765       };
85766     } catch (std::exception& e) {
85767       {
85768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85769       };
85770     } catch (Dali::DaliException e) {
85771       {
85772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85773       };
85774     } catch (...) {
85775       {
85776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85777       };
85778     }
85779   }
85780
85781 }
85782
85783
85784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
85785   void * jresult ;
85786   Dali::Toolkit::ProgressBar result;
85787
85788   {
85789     try {
85790       result = Dali::Toolkit::ProgressBar::New();
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 = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
85811   return jresult;
85812 }
85813
85814
85815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
85816   void * jresult ;
85817   Dali::Toolkit::ProgressBar *result = 0 ;
85818
85819   {
85820     try {
85821       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
85822     } catch (std::out_of_range& e) {
85823       {
85824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85825       };
85826     } catch (std::exception& e) {
85827       {
85828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85829       };
85830     } catch (Dali::DaliException e) {
85831       {
85832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85833       };
85834     } catch (...) {
85835       {
85836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85837       };
85838     }
85839   }
85840
85841   jresult = (void *)result;
85842   return jresult;
85843 }
85844
85845
85846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
85847   void * jresult ;
85848   Dali::Toolkit::ProgressBar *arg1 = 0 ;
85849   Dali::Toolkit::ProgressBar *result = 0 ;
85850
85851   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
85852   if (!arg1) {
85853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
85854     return 0;
85855   }
85856   {
85857     try {
85858       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
85859     } catch (std::out_of_range& e) {
85860       {
85861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85862       };
85863     } catch (std::exception& e) {
85864       {
85865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85866       };
85867     } catch (Dali::DaliException e) {
85868       {
85869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85870       };
85871     } catch (...) {
85872       {
85873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85874       };
85875     }
85876   }
85877
85878   jresult = (void *)result;
85879   return jresult;
85880 }
85881
85882
85883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
85884   void * jresult ;
85885   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
85886   Dali::Toolkit::ProgressBar *arg2 = 0 ;
85887   Dali::Toolkit::ProgressBar *result = 0 ;
85888
85889   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
85890   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
85891   if (!arg2) {
85892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
85893     return 0;
85894   }
85895   {
85896     try {
85897       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
85898     } catch (std::out_of_range& e) {
85899       {
85900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85901       };
85902     } catch (std::exception& e) {
85903       {
85904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85905       };
85906     } catch (Dali::DaliException e) {
85907       {
85908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85909       };
85910     } catch (...) {
85911       {
85912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85913       };
85914     }
85915   }
85916
85917   jresult = (void *)result;
85918   return jresult;
85919 }
85920
85921
85922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
85923   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
85924
85925   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
85926   {
85927     try {
85928       delete arg1;
85929     } catch (std::out_of_range& e) {
85930       {
85931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85932       };
85933     } catch (std::exception& e) {
85934       {
85935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85936       };
85937     } catch (Dali::DaliException e) {
85938       {
85939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85940       };
85941     } catch (...) {
85942       {
85943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85944       };
85945     }
85946   }
85947
85948 }
85949
85950
85951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
85952   void * jresult ;
85953   Dali::BaseHandle arg1 ;
85954   Dali::BaseHandle *argp1 ;
85955   Dali::Toolkit::ProgressBar result;
85956
85957   argp1 = (Dali::BaseHandle *)jarg1;
85958   if (!argp1) {
85959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85960     return 0;
85961   }
85962   arg1 = *argp1;
85963   {
85964     try {
85965       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
85966     } catch (std::out_of_range& e) {
85967       {
85968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85969       };
85970     } catch (std::exception& e) {
85971       {
85972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85973       };
85974     } catch (Dali::DaliException e) {
85975       {
85976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85977       };
85978     } catch (...) {
85979       {
85980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85981       };
85982     }
85983   }
85984
85985   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
85986   return jresult;
85987 }
85988
85989
85990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
85991   void * jresult ;
85992   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
85993   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
85994
85995   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
85996   {
85997     try {
85998       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85999     } catch (std::out_of_range& e) {
86000       {
86001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86002       };
86003     } catch (std::exception& e) {
86004       {
86005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86006       };
86007     } catch (Dali::DaliException e) {
86008       {
86009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86010       };
86011     } catch (...) {
86012       {
86013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86014       };
86015     }
86016   }
86017
86018   jresult = (void *)result;
86019   return jresult;
86020 }
86021
86022
86023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
86024   void * jresult ;
86025   Dali::Toolkit::GaussianBlurView *result = 0 ;
86026
86027   {
86028     try {
86029       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
86030     } catch (std::out_of_range& e) {
86031       {
86032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86033       };
86034     } catch (std::exception& e) {
86035       {
86036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86037       };
86038     } catch (Dali::DaliException e) {
86039       {
86040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86041       };
86042     } catch (...) {
86043       {
86044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86045       };
86046     }
86047   }
86048
86049   jresult = (void *)result;
86050   return jresult;
86051 }
86052
86053
86054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
86055   void * jresult ;
86056   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
86057   Dali::Toolkit::GaussianBlurView *result = 0 ;
86058
86059   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86060   if (!arg1) {
86061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
86062     return 0;
86063   }
86064   {
86065     try {
86066       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
86067     } catch (std::out_of_range& e) {
86068       {
86069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86070       };
86071     } catch (std::exception& e) {
86072       {
86073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86074       };
86075     } catch (Dali::DaliException e) {
86076       {
86077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86078       };
86079     } catch (...) {
86080       {
86081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86082       };
86083     }
86084   }
86085
86086   jresult = (void *)result;
86087   return jresult;
86088 }
86089
86090
86091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
86092   void * jresult ;
86093   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86094   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
86095   Dali::Toolkit::GaussianBlurView *result = 0 ;
86096
86097   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86098   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
86099   if (!arg2) {
86100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
86101     return 0;
86102   }
86103   {
86104     try {
86105       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
86106     } catch (std::out_of_range& e) {
86107       {
86108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86109       };
86110     } catch (std::exception& e) {
86111       {
86112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86113       };
86114     } catch (Dali::DaliException e) {
86115       {
86116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86117       };
86118     } catch (...) {
86119       {
86120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86121       };
86122     }
86123   }
86124
86125   jresult = (void *)result;
86126   return jresult;
86127 }
86128
86129
86130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
86131   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86132
86133   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86134   {
86135     try {
86136       delete arg1;
86137     } catch (std::out_of_range& e) {
86138       {
86139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86140       };
86141     } catch (std::exception& e) {
86142       {
86143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86144       };
86145     } catch (Dali::DaliException e) {
86146       {
86147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86148       };
86149     } catch (...) {
86150       {
86151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86152       };
86153     }
86154   }
86155
86156 }
86157
86158
86159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
86160   void * jresult ;
86161   Dali::BaseHandle arg1 ;
86162   Dali::BaseHandle *argp1 ;
86163   Dali::Toolkit::GaussianBlurView result;
86164
86165   argp1 = (Dali::BaseHandle *)jarg1;
86166   if (!argp1) {
86167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86168     return 0;
86169   }
86170   arg1 = *argp1;
86171   {
86172     try {
86173       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
86174     } catch (std::out_of_range& e) {
86175       {
86176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86177       };
86178     } catch (std::exception& e) {
86179       {
86180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86181       };
86182     } catch (Dali::DaliException e) {
86183       {
86184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86185       };
86186     } catch (...) {
86187       {
86188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86189       };
86190     }
86191   }
86192
86193   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
86194   return jresult;
86195 }
86196
86197
86198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
86199   void * jresult ;
86200   Dali::Toolkit::GaussianBlurView result;
86201
86202   {
86203     try {
86204       result = Dali::Toolkit::GaussianBlurView::New();
86205     } catch (std::out_of_range& e) {
86206       {
86207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86208       };
86209     } catch (std::exception& e) {
86210       {
86211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86212       };
86213     } catch (Dali::DaliException e) {
86214       {
86215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86216       };
86217     } catch (...) {
86218       {
86219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86220       };
86221     }
86222   }
86223
86224   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
86225   return jresult;
86226 }
86227
86228
86229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
86230   void * jresult ;
86231   unsigned int arg1 ;
86232   float arg2 ;
86233   Dali::Pixel::Format arg3 ;
86234   float arg4 ;
86235   float arg5 ;
86236   bool arg6 ;
86237   Dali::Toolkit::GaussianBlurView result;
86238
86239   arg1 = (unsigned int)jarg1;
86240   arg2 = (float)jarg2;
86241   arg3 = (Dali::Pixel::Format)jarg3;
86242   arg4 = (float)jarg4;
86243   arg5 = (float)jarg5;
86244   arg6 = jarg6 ? true : false;
86245   {
86246     try {
86247       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
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 = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
86268   return jresult;
86269 }
86270
86271
86272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
86273   void * jresult ;
86274   unsigned int arg1 ;
86275   float arg2 ;
86276   Dali::Pixel::Format arg3 ;
86277   float arg4 ;
86278   float arg5 ;
86279   Dali::Toolkit::GaussianBlurView result;
86280
86281   arg1 = (unsigned int)jarg1;
86282   arg2 = (float)jarg2;
86283   arg3 = (Dali::Pixel::Format)jarg3;
86284   arg4 = (float)jarg4;
86285   arg5 = (float)jarg5;
86286   {
86287     try {
86288       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
86289     } catch (std::out_of_range& e) {
86290       {
86291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86292       };
86293     } catch (std::exception& e) {
86294       {
86295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86296       };
86297     } catch (Dali::DaliException e) {
86298       {
86299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86300       };
86301     } catch (...) {
86302       {
86303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86304       };
86305     }
86306   }
86307
86308   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
86309   return jresult;
86310 }
86311
86312
86313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
86314   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86315   Dali::Actor arg2 ;
86316   Dali::Actor *argp2 ;
86317
86318   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86319   argp2 = (Dali::Actor *)jarg2;
86320   if (!argp2) {
86321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86322     return ;
86323   }
86324   arg2 = *argp2;
86325   {
86326     try {
86327       (arg1)->Add(arg2);
86328     } catch (std::out_of_range& e) {
86329       {
86330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86331       };
86332     } catch (std::exception& e) {
86333       {
86334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86335       };
86336     } catch (Dali::DaliException e) {
86337       {
86338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86339       };
86340     } catch (...) {
86341       {
86342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86343       };
86344     }
86345   }
86346
86347 }
86348
86349
86350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
86351   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86352   Dali::Actor arg2 ;
86353   Dali::Actor *argp2 ;
86354
86355   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86356   argp2 = (Dali::Actor *)jarg2;
86357   if (!argp2) {
86358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86359     return ;
86360   }
86361   arg2 = *argp2;
86362   {
86363     try {
86364       (arg1)->Remove(arg2);
86365     } catch (std::out_of_range& e) {
86366       {
86367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86368       };
86369     } catch (std::exception& e) {
86370       {
86371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86372       };
86373     } catch (Dali::DaliException e) {
86374       {
86375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86376       };
86377     } catch (...) {
86378       {
86379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86380       };
86381     }
86382   }
86383
86384 }
86385
86386
86387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
86388   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86389
86390   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86391   {
86392     try {
86393       (arg1)->Activate();
86394     } catch (std::out_of_range& e) {
86395       {
86396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86397       };
86398     } catch (std::exception& e) {
86399       {
86400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86401       };
86402     } catch (Dali::DaliException e) {
86403       {
86404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86405       };
86406     } catch (...) {
86407       {
86408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86409       };
86410     }
86411   }
86412
86413 }
86414
86415
86416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
86417   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86418
86419   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86420   {
86421     try {
86422       (arg1)->ActivateOnce();
86423     } catch (std::out_of_range& e) {
86424       {
86425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86426       };
86427     } catch (std::exception& e) {
86428       {
86429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86430       };
86431     } catch (Dali::DaliException e) {
86432       {
86433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86434       };
86435     } catch (...) {
86436       {
86437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86438       };
86439     }
86440   }
86441
86442 }
86443
86444
86445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
86446   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86447
86448   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86449   {
86450     try {
86451       (arg1)->Deactivate();
86452     } catch (std::out_of_range& e) {
86453       {
86454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86455       };
86456     } catch (std::exception& e) {
86457       {
86458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86459       };
86460     } catch (Dali::DaliException e) {
86461       {
86462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86463       };
86464     } catch (...) {
86465       {
86466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86467       };
86468     }
86469   }
86470
86471 }
86472
86473
86474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
86475   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86476   Dali::Texture arg2 ;
86477   Dali::FrameBuffer arg3 ;
86478   Dali::Texture *argp2 ;
86479   Dali::FrameBuffer *argp3 ;
86480
86481   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86482   argp2 = (Dali::Texture *)jarg2;
86483   if (!argp2) {
86484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
86485     return ;
86486   }
86487   arg2 = *argp2;
86488   argp3 = (Dali::FrameBuffer *)jarg3;
86489   if (!argp3) {
86490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
86491     return ;
86492   }
86493   arg3 = *argp3;
86494   {
86495     try {
86496       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
86497     } catch (std::out_of_range& e) {
86498       {
86499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86500       };
86501     } catch (std::exception& e) {
86502       {
86503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86504       };
86505     } catch (Dali::DaliException e) {
86506       {
86507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86508       };
86509     } catch (...) {
86510       {
86511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86512       };
86513     }
86514   }
86515
86516 }
86517
86518
86519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
86520   int jresult ;
86521   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86522   Dali::Property::Index result;
86523
86524   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86525   {
86526     try {
86527       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
86528     } catch (std::out_of_range& e) {
86529       {
86530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86531       };
86532     } catch (std::exception& e) {
86533       {
86534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86535       };
86536     } catch (Dali::DaliException e) {
86537       {
86538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86539       };
86540     } catch (...) {
86541       {
86542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86543       };
86544     }
86545   }
86546
86547   jresult = result;
86548   return jresult;
86549 }
86550
86551
86552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
86553   void * jresult ;
86554   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86555   Dali::FrameBuffer result;
86556
86557   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86558   {
86559     try {
86560       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
86561     } catch (std::out_of_range& e) {
86562       {
86563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86564       };
86565     } catch (std::exception& e) {
86566       {
86567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86568       };
86569     } catch (Dali::DaliException e) {
86570       {
86571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86572       };
86573     } catch (...) {
86574       {
86575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86576       };
86577     }
86578   }
86579
86580   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
86581   return jresult;
86582 }
86583
86584
86585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
86586   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86587   Dali::Vector4 *arg2 = 0 ;
86588
86589   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86590   arg2 = (Dali::Vector4 *)jarg2;
86591   if (!arg2) {
86592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
86593     return ;
86594   }
86595   {
86596     try {
86597       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
86598     } catch (std::out_of_range& e) {
86599       {
86600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86601       };
86602     } catch (std::exception& e) {
86603       {
86604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86605       };
86606     } catch (Dali::DaliException e) {
86607       {
86608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86609       };
86610     } catch (...) {
86611       {
86612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86613       };
86614     }
86615   }
86616
86617 }
86618
86619
86620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
86621   void * jresult ;
86622   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86623   Dali::Vector4 result;
86624
86625   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86626   {
86627     try {
86628       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
86629     } catch (std::out_of_range& e) {
86630       {
86631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86632       };
86633     } catch (std::exception& e) {
86634       {
86635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86636       };
86637     } catch (Dali::DaliException e) {
86638       {
86639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86640       };
86641     } catch (...) {
86642       {
86643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86644       };
86645     }
86646   }
86647
86648   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
86649   return jresult;
86650 }
86651
86652
86653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
86654   void * jresult ;
86655   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86656   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
86657
86658   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86659   {
86660     try {
86661       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
86662     } catch (std::out_of_range& e) {
86663       {
86664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86665       };
86666     } catch (std::exception& e) {
86667       {
86668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86669       };
86670     } catch (Dali::DaliException e) {
86671       {
86672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86673       };
86674     } catch (...) {
86675       {
86676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86677       };
86678     }
86679   }
86680
86681   jresult = (void *)result;
86682   return jresult;
86683 }
86684
86685
86686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
86687   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
86688
86689   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
86690   {
86691     try {
86692       delete arg1;
86693     } catch (std::out_of_range& e) {
86694       {
86695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86696       };
86697     } catch (std::exception& e) {
86698       {
86699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86700       };
86701     } catch (Dali::DaliException e) {
86702       {
86703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86704       };
86705     } catch (...) {
86706       {
86707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86708       };
86709     }
86710   }
86711
86712 }
86713
86714
86715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
86716   unsigned int jresult ;
86717   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
86718   unsigned int result;
86719
86720   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
86721   {
86722     try {
86723       result = (unsigned int)(arg1)->GetNumberOfPages();
86724     } catch (std::out_of_range& e) {
86725       {
86726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86727       };
86728     } catch (std::exception& e) {
86729       {
86730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86731       };
86732     } catch (Dali::DaliException e) {
86733       {
86734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86735       };
86736     } catch (...) {
86737       {
86738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86739       };
86740     }
86741   }
86742
86743   jresult = result;
86744   return jresult;
86745 }
86746
86747
86748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
86749   void * jresult ;
86750   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
86751   unsigned int arg2 ;
86752   Dali::Texture result;
86753
86754   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
86755   arg2 = (unsigned int)jarg2;
86756   {
86757     try {
86758       result = (arg1)->NewPage(arg2);
86759     } catch (std::out_of_range& e) {
86760       {
86761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86762       };
86763     } catch (std::exception& e) {
86764       {
86765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86766       };
86767     } catch (Dali::DaliException e) {
86768       {
86769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86770       };
86771     } catch (...) {
86772       {
86773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86774       };
86775     }
86776   }
86777
86778   jresult = new Dali::Texture((const Dali::Texture &)result);
86779   return jresult;
86780 }
86781
86782
86783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
86784   int jresult ;
86785   int result;
86786
86787   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
86788   jresult = (int)result;
86789   return jresult;
86790 }
86791
86792
86793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
86794   int jresult ;
86795   int result;
86796
86797   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
86798   jresult = (int)result;
86799   return jresult;
86800 }
86801
86802
86803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
86804   int jresult ;
86805   int result;
86806
86807   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
86808   jresult = (int)result;
86809   return jresult;
86810 }
86811
86812
86813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
86814   void * jresult ;
86815   Dali::Toolkit::PageTurnView::Property *result = 0 ;
86816
86817   {
86818     try {
86819       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
86820     } catch (std::out_of_range& e) {
86821       {
86822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86823       };
86824     } catch (std::exception& e) {
86825       {
86826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86827       };
86828     } catch (Dali::DaliException e) {
86829       {
86830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86831       };
86832     } catch (...) {
86833       {
86834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86835       };
86836     }
86837   }
86838
86839   jresult = (void *)result;
86840   return jresult;
86841 }
86842
86843
86844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
86845   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
86846
86847   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
86848   {
86849     try {
86850       delete arg1;
86851     } catch (std::out_of_range& e) {
86852       {
86853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86854       };
86855     } catch (std::exception& e) {
86856       {
86857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86858       };
86859     } catch (Dali::DaliException e) {
86860       {
86861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86862       };
86863     } catch (...) {
86864       {
86865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86866       };
86867     }
86868   }
86869
86870 }
86871
86872
86873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
86874   void * jresult ;
86875   Dali::Toolkit::PageTurnView *result = 0 ;
86876
86877   {
86878     try {
86879       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
86880     } catch (std::out_of_range& e) {
86881       {
86882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86883       };
86884     } catch (std::exception& e) {
86885       {
86886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86887       };
86888     } catch (Dali::DaliException e) {
86889       {
86890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86891       };
86892     } catch (...) {
86893       {
86894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86895       };
86896     }
86897   }
86898
86899   jresult = (void *)result;
86900   return jresult;
86901 }
86902
86903
86904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
86905   void * jresult ;
86906   Dali::Toolkit::PageTurnView *arg1 = 0 ;
86907   Dali::Toolkit::PageTurnView *result = 0 ;
86908
86909   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
86910   if (!arg1) {
86911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
86912     return 0;
86913   }
86914   {
86915     try {
86916       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
86917     } catch (std::out_of_range& e) {
86918       {
86919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86920       };
86921     } catch (std::exception& e) {
86922       {
86923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86924       };
86925     } catch (Dali::DaliException e) {
86926       {
86927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86928       };
86929     } catch (...) {
86930       {
86931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86932       };
86933     }
86934   }
86935
86936   jresult = (void *)result;
86937   return jresult;
86938 }
86939
86940
86941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
86942   void * jresult ;
86943   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
86944   Dali::Toolkit::PageTurnView *arg2 = 0 ;
86945   Dali::Toolkit::PageTurnView *result = 0 ;
86946
86947   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
86948   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
86949   if (!arg2) {
86950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
86951     return 0;
86952   }
86953   {
86954     try {
86955       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
86956     } catch (std::out_of_range& e) {
86957       {
86958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86959       };
86960     } catch (std::exception& e) {
86961       {
86962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86963       };
86964     } catch (Dali::DaliException e) {
86965       {
86966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86967       };
86968     } catch (...) {
86969       {
86970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86971       };
86972     }
86973   }
86974
86975   jresult = (void *)result;
86976   return jresult;
86977 }
86978
86979
86980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
86981   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
86982
86983   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
86984   {
86985     try {
86986       delete arg1;
86987     } catch (std::out_of_range& e) {
86988       {
86989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86990       };
86991     } catch (std::exception& e) {
86992       {
86993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86994       };
86995     } catch (Dali::DaliException e) {
86996       {
86997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86998       };
86999     } catch (...) {
87000       {
87001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87002       };
87003     }
87004   }
87005
87006 }
87007
87008
87009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
87010   void * jresult ;
87011   Dali::BaseHandle arg1 ;
87012   Dali::BaseHandle *argp1 ;
87013   Dali::Toolkit::PageTurnView result;
87014
87015   argp1 = (Dali::BaseHandle *)jarg1;
87016   if (!argp1) {
87017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87018     return 0;
87019   }
87020   arg1 = *argp1;
87021   {
87022     try {
87023       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
87024     } catch (std::out_of_range& e) {
87025       {
87026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87027       };
87028     } catch (std::exception& e) {
87029       {
87030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87031       };
87032     } catch (Dali::DaliException e) {
87033       {
87034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87035       };
87036     } catch (...) {
87037       {
87038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87039       };
87040     }
87041   }
87042
87043   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
87044   return jresult;
87045 }
87046
87047
87048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
87049   void * jresult ;
87050   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
87051   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
87052
87053   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87054   {
87055     try {
87056       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
87057     } catch (std::out_of_range& e) {
87058       {
87059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87060       };
87061     } catch (std::exception& e) {
87062       {
87063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87064       };
87065     } catch (Dali::DaliException e) {
87066       {
87067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87068       };
87069     } catch (...) {
87070       {
87071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87072       };
87073     }
87074   }
87075
87076   jresult = (void *)result;
87077   return jresult;
87078 }
87079
87080
87081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
87082   void * jresult ;
87083   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
87084   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
87085
87086   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87087   {
87088     try {
87089       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
87090     } catch (std::out_of_range& e) {
87091       {
87092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87093       };
87094     } catch (std::exception& e) {
87095       {
87096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87097       };
87098     } catch (Dali::DaliException e) {
87099       {
87100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87101       };
87102     } catch (...) {
87103       {
87104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87105       };
87106     }
87107   }
87108
87109   jresult = (void *)result;
87110   return jresult;
87111 }
87112
87113
87114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
87115   void * jresult ;
87116   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
87117   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
87118
87119   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87120   {
87121     try {
87122       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
87123     } catch (std::out_of_range& e) {
87124       {
87125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87126       };
87127     } catch (std::exception& e) {
87128       {
87129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87130       };
87131     } catch (Dali::DaliException e) {
87132       {
87133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87134       };
87135     } catch (...) {
87136       {
87137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87138       };
87139     }
87140   }
87141
87142   jresult = (void *)result;
87143   return jresult;
87144 }
87145
87146
87147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
87148   void * jresult ;
87149   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
87150   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
87151
87152   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87153   {
87154     try {
87155       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
87156     } catch (std::out_of_range& e) {
87157       {
87158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87159       };
87160     } catch (std::exception& e) {
87161       {
87162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87163       };
87164     } catch (Dali::DaliException e) {
87165       {
87166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87167       };
87168     } catch (...) {
87169       {
87170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87171       };
87172     }
87173   }
87174
87175   jresult = (void *)result;
87176   return jresult;
87177 }
87178
87179
87180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
87181   void * jresult ;
87182   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
87183
87184   {
87185     try {
87186       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
87187     } catch (std::out_of_range& e) {
87188       {
87189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87190       };
87191     } catch (std::exception& e) {
87192       {
87193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87194       };
87195     } catch (Dali::DaliException e) {
87196       {
87197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87198       };
87199     } catch (...) {
87200       {
87201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87202       };
87203     }
87204   }
87205
87206   jresult = (void *)result;
87207   return jresult;
87208 }
87209
87210
87211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
87212   void * jresult ;
87213   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
87214   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
87215
87216   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
87217   if (!arg1) {
87218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
87219     return 0;
87220   }
87221   {
87222     try {
87223       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
87224     } catch (std::out_of_range& e) {
87225       {
87226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87227       };
87228     } catch (std::exception& e) {
87229       {
87230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87231       };
87232     } catch (Dali::DaliException e) {
87233       {
87234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87235       };
87236     } catch (...) {
87237       {
87238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87239       };
87240     }
87241   }
87242
87243   jresult = (void *)result;
87244   return jresult;
87245 }
87246
87247
87248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
87249   void * jresult ;
87250   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
87251   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
87252   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
87253
87254   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
87255   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
87256   if (!arg2) {
87257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
87258     return 0;
87259   }
87260   {
87261     try {
87262       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
87263     } catch (std::out_of_range& e) {
87264       {
87265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87266       };
87267     } catch (std::exception& e) {
87268       {
87269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87270       };
87271     } catch (Dali::DaliException e) {
87272       {
87273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87274       };
87275     } catch (...) {
87276       {
87277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87278       };
87279     }
87280   }
87281
87282   jresult = (void *)result;
87283   return jresult;
87284 }
87285
87286
87287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
87288   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
87289
87290   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
87291   {
87292     try {
87293       delete arg1;
87294     } catch (std::out_of_range& e) {
87295       {
87296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87297       };
87298     } catch (std::exception& e) {
87299       {
87300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87301       };
87302     } catch (Dali::DaliException e) {
87303       {
87304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87305       };
87306     } catch (...) {
87307       {
87308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87309       };
87310     }
87311   }
87312
87313 }
87314
87315
87316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
87317   void * jresult ;
87318   Dali::Toolkit::PageFactory *arg1 = 0 ;
87319   Dali::Vector2 *arg2 = 0 ;
87320   Dali::Toolkit::PageTurnLandscapeView result;
87321
87322   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
87323   if (!arg1) {
87324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
87325     return 0;
87326   }
87327   arg2 = (Dali::Vector2 *)jarg2;
87328   if (!arg2) {
87329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
87330     return 0;
87331   }
87332   {
87333     try {
87334       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
87335     } catch (std::out_of_range& e) {
87336       {
87337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87338       };
87339     } catch (std::exception& e) {
87340       {
87341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87342       };
87343     } catch (Dali::DaliException e) {
87344       {
87345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87346       };
87347     } catch (...) {
87348       {
87349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87350       };
87351     }
87352   }
87353
87354   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
87355   return jresult;
87356 }
87357
87358
87359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
87360   void * jresult ;
87361   Dali::BaseHandle arg1 ;
87362   Dali::BaseHandle *argp1 ;
87363   Dali::Toolkit::PageTurnLandscapeView result;
87364
87365   argp1 = (Dali::BaseHandle *)jarg1;
87366   if (!argp1) {
87367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87368     return 0;
87369   }
87370   arg1 = *argp1;
87371   {
87372     try {
87373       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
87374     } catch (std::out_of_range& e) {
87375       {
87376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87377       };
87378     } catch (std::exception& e) {
87379       {
87380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87381       };
87382     } catch (Dali::DaliException e) {
87383       {
87384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87385       };
87386     } catch (...) {
87387       {
87388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87389       };
87390     }
87391   }
87392
87393   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
87394   return jresult;
87395 }
87396
87397
87398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
87399   void * jresult ;
87400   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
87401
87402   {
87403     try {
87404       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
87405     } catch (std::out_of_range& e) {
87406       {
87407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87408       };
87409     } catch (std::exception& e) {
87410       {
87411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87412       };
87413     } catch (Dali::DaliException e) {
87414       {
87415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87416       };
87417     } catch (...) {
87418       {
87419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87420       };
87421     }
87422   }
87423
87424   jresult = (void *)result;
87425   return jresult;
87426 }
87427
87428
87429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
87430   void * jresult ;
87431   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
87432   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
87433
87434   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
87435   if (!arg1) {
87436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
87437     return 0;
87438   }
87439   {
87440     try {
87441       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
87442     } catch (std::out_of_range& e) {
87443       {
87444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87445       };
87446     } catch (std::exception& e) {
87447       {
87448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87449       };
87450     } catch (Dali::DaliException e) {
87451       {
87452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87453       };
87454     } catch (...) {
87455       {
87456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87457       };
87458     }
87459   }
87460
87461   jresult = (void *)result;
87462   return jresult;
87463 }
87464
87465
87466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
87467   void * jresult ;
87468   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
87469   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
87470   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
87471
87472   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
87473   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
87474   if (!arg2) {
87475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
87476     return 0;
87477   }
87478   {
87479     try {
87480       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
87481     } catch (std::out_of_range& e) {
87482       {
87483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87484       };
87485     } catch (std::exception& e) {
87486       {
87487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87488       };
87489     } catch (Dali::DaliException e) {
87490       {
87491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87492       };
87493     } catch (...) {
87494       {
87495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87496       };
87497     }
87498   }
87499
87500   jresult = (void *)result;
87501   return jresult;
87502 }
87503
87504
87505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
87506   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
87507
87508   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
87509   {
87510     try {
87511       delete arg1;
87512     } catch (std::out_of_range& e) {
87513       {
87514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87515       };
87516     } catch (std::exception& e) {
87517       {
87518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87519       };
87520     } catch (Dali::DaliException e) {
87521       {
87522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87523       };
87524     } catch (...) {
87525       {
87526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87527       };
87528     }
87529   }
87530
87531 }
87532
87533
87534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
87535   void * jresult ;
87536   Dali::Toolkit::PageFactory *arg1 = 0 ;
87537   Dali::Vector2 *arg2 = 0 ;
87538   Dali::Toolkit::PageTurnPortraitView result;
87539
87540   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
87541   if (!arg1) {
87542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
87543     return 0;
87544   }
87545   arg2 = (Dali::Vector2 *)jarg2;
87546   if (!arg2) {
87547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
87548     return 0;
87549   }
87550   {
87551     try {
87552       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
87553     } catch (std::out_of_range& e) {
87554       {
87555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87556       };
87557     } catch (std::exception& e) {
87558       {
87559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87560       };
87561     } catch (Dali::DaliException e) {
87562       {
87563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87564       };
87565     } catch (...) {
87566       {
87567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87568       };
87569     }
87570   }
87571
87572   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
87573   return jresult;
87574 }
87575
87576
87577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
87578   void * jresult ;
87579   Dali::BaseHandle arg1 ;
87580   Dali::BaseHandle *argp1 ;
87581   Dali::Toolkit::PageTurnPortraitView result;
87582
87583   argp1 = (Dali::BaseHandle *)jarg1;
87584   if (!argp1) {
87585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87586     return 0;
87587   }
87588   arg1 = *argp1;
87589   {
87590     try {
87591       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
87592     } catch (std::out_of_range& e) {
87593       {
87594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87595       };
87596     } catch (std::exception& e) {
87597       {
87598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87599       };
87600     } catch (Dali::DaliException e) {
87601       {
87602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87603       };
87604     } catch (...) {
87605       {
87606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87607       };
87608     }
87609   }
87610
87611   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
87612   return jresult;
87613 }
87614
87615
87616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
87617   int jresult ;
87618   int result;
87619
87620   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
87621   jresult = (int)result;
87622   return jresult;
87623 }
87624
87625
87626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
87627   int jresult ;
87628   int result;
87629
87630   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
87631   jresult = (int)result;
87632   return jresult;
87633 }
87634
87635
87636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
87637   int jresult ;
87638   int result;
87639
87640   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
87641   jresult = (int)result;
87642   return jresult;
87643 }
87644
87645
87646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
87647   void * jresult ;
87648   Dali::Toolkit::ToggleButton::Property *result = 0 ;
87649
87650   {
87651     try {
87652       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
87653     } catch (std::out_of_range& e) {
87654       {
87655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87656       };
87657     } catch (std::exception& e) {
87658       {
87659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87660       };
87661     } catch (Dali::DaliException e) {
87662       {
87663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87664       };
87665     } catch (...) {
87666       {
87667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87668       };
87669     }
87670   }
87671
87672   jresult = (void *)result;
87673   return jresult;
87674 }
87675
87676
87677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
87678   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
87679
87680   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
87681   {
87682     try {
87683       delete arg1;
87684     } catch (std::out_of_range& e) {
87685       {
87686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87687       };
87688     } catch (std::exception& e) {
87689       {
87690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87691       };
87692     } catch (Dali::DaliException e) {
87693       {
87694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87695       };
87696     } catch (...) {
87697       {
87698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87699       };
87700     }
87701   }
87702
87703 }
87704
87705
87706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
87707   void * jresult ;
87708   Dali::Toolkit::ToggleButton *result = 0 ;
87709
87710   {
87711     try {
87712       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
87713     } catch (std::out_of_range& e) {
87714       {
87715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87716       };
87717     } catch (std::exception& e) {
87718       {
87719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87720       };
87721     } catch (Dali::DaliException e) {
87722       {
87723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87724       };
87725     } catch (...) {
87726       {
87727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87728       };
87729     }
87730   }
87731
87732   jresult = (void *)result;
87733   return jresult;
87734 }
87735
87736
87737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
87738   void * jresult ;
87739   Dali::Toolkit::ToggleButton *arg1 = 0 ;
87740   Dali::Toolkit::ToggleButton *result = 0 ;
87741
87742   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
87743   if (!arg1) {
87744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
87745     return 0;
87746   }
87747   {
87748     try {
87749       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
87750     } catch (std::out_of_range& e) {
87751       {
87752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87753       };
87754     } catch (std::exception& e) {
87755       {
87756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87757       };
87758     } catch (Dali::DaliException e) {
87759       {
87760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87761       };
87762     } catch (...) {
87763       {
87764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87765       };
87766     }
87767   }
87768
87769   jresult = (void *)result;
87770   return jresult;
87771 }
87772
87773
87774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
87775   void * jresult ;
87776   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
87777   Dali::Toolkit::ToggleButton *arg2 = 0 ;
87778   Dali::Toolkit::ToggleButton *result = 0 ;
87779
87780   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
87781   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
87782   if (!arg2) {
87783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
87784     return 0;
87785   }
87786   {
87787     try {
87788       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
87789     } catch (std::out_of_range& e) {
87790       {
87791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87792       };
87793     } catch (std::exception& e) {
87794       {
87795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87796       };
87797     } catch (Dali::DaliException e) {
87798       {
87799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87800       };
87801     } catch (...) {
87802       {
87803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87804       };
87805     }
87806   }
87807
87808   jresult = (void *)result;
87809   return jresult;
87810 }
87811
87812
87813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
87814   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
87815
87816   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
87817   {
87818     try {
87819       delete arg1;
87820     } catch (std::out_of_range& e) {
87821       {
87822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87823       };
87824     } catch (std::exception& e) {
87825       {
87826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87827       };
87828     } catch (Dali::DaliException e) {
87829       {
87830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87831       };
87832     } catch (...) {
87833       {
87834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87835       };
87836     }
87837   }
87838
87839 }
87840
87841
87842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
87843   void * jresult ;
87844   Dali::Toolkit::ToggleButton result;
87845
87846   {
87847     try {
87848       result = Dali::Toolkit::ToggleButton::New();
87849     } catch (std::out_of_range& e) {
87850       {
87851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87852       };
87853     } catch (std::exception& e) {
87854       {
87855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87856       };
87857     } catch (Dali::DaliException e) {
87858       {
87859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87860       };
87861     } catch (...) {
87862       {
87863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87864       };
87865     }
87866   }
87867
87868   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
87869   return jresult;
87870 }
87871
87872
87873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
87874   void * jresult ;
87875   Dali::BaseHandle arg1 ;
87876   Dali::BaseHandle *argp1 ;
87877   Dali::Toolkit::ToggleButton result;
87878
87879   argp1 = (Dali::BaseHandle *)jarg1;
87880   if (!argp1) {
87881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87882     return 0;
87883   }
87884   arg1 = *argp1;
87885   {
87886     try {
87887       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
87888     } catch (std::out_of_range& e) {
87889       {
87890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87891       };
87892     } catch (std::exception& e) {
87893       {
87894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87895       };
87896     } catch (Dali::DaliException e) {
87897       {
87898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87899       };
87900     } catch (...) {
87901       {
87902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87903       };
87904     }
87905   }
87906
87907   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
87908   return jresult;
87909 }
87910
87911
87912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
87913   void * jresult ;
87914   Dali::Toolkit::Visual::Base *result = 0 ;
87915
87916   {
87917     try {
87918       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
87919     } catch (std::out_of_range& e) {
87920       {
87921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87922       };
87923     } catch (std::exception& e) {
87924       {
87925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87926       };
87927     } catch (Dali::DaliException e) {
87928       {
87929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87930       };
87931     } catch (...) {
87932       {
87933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87934       };
87935     }
87936   }
87937
87938   jresult = (void *)result;
87939   return jresult;
87940 }
87941
87942
87943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
87944   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
87945
87946   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87947   {
87948     try {
87949       delete arg1;
87950     } catch (std::out_of_range& e) {
87951       {
87952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87953       };
87954     } catch (std::exception& e) {
87955       {
87956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87957       };
87958     } catch (Dali::DaliException e) {
87959       {
87960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87961       };
87962     } catch (...) {
87963       {
87964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87965       };
87966     }
87967   }
87968
87969 }
87970
87971
87972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
87973   void * jresult ;
87974   Dali::Toolkit::Visual::Base *arg1 = 0 ;
87975   Dali::Toolkit::Visual::Base *result = 0 ;
87976
87977   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
87978   if (!arg1) {
87979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
87980     return 0;
87981   }
87982   {
87983     try {
87984       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
87985     } catch (std::out_of_range& e) {
87986       {
87987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87988       };
87989     } catch (std::exception& e) {
87990       {
87991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87992       };
87993     } catch (Dali::DaliException e) {
87994       {
87995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87996       };
87997     } catch (...) {
87998       {
87999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88000       };
88001     }
88002   }
88003
88004   jresult = (void *)result;
88005   return jresult;
88006 }
88007
88008
88009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
88010   void * jresult ;
88011   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88012   Dali::Toolkit::Visual::Base *arg2 = 0 ;
88013   Dali::Toolkit::Visual::Base *result = 0 ;
88014
88015   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88016   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
88017   if (!arg2) {
88018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
88019     return 0;
88020   }
88021   {
88022     try {
88023       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
88024     } catch (std::out_of_range& e) {
88025       {
88026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88027       };
88028     } catch (std::exception& e) {
88029       {
88030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88031       };
88032     } catch (Dali::DaliException e) {
88033       {
88034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88035       };
88036     } catch (...) {
88037       {
88038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88039       };
88040     }
88041   }
88042
88043   jresult = (void *)result;
88044   return jresult;
88045 }
88046
88047
88048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
88049   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88050   std::string *arg2 = 0 ;
88051
88052   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88053   if (!jarg2) {
88054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88055     return ;
88056   }
88057   std::string arg2_str(jarg2);
88058   arg2 = &arg2_str;
88059   {
88060     try {
88061       (arg1)->SetName((std::string const &)*arg2);
88062     } catch (std::out_of_range& e) {
88063       {
88064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88065       };
88066     } catch (std::exception& e) {
88067       {
88068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88069       };
88070     } catch (Dali::DaliException e) {
88071       {
88072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88073       };
88074     } catch (...) {
88075       {
88076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88077       };
88078     }
88079   }
88080
88081
88082   //argout typemap for const std::string&
88083
88084 }
88085
88086
88087 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
88088   char * jresult ;
88089   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88090   std::string *result = 0 ;
88091
88092   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88093   {
88094     try {
88095       result = (std::string *) &(arg1)->GetName();
88096     } catch (std::out_of_range& e) {
88097       {
88098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88099       };
88100     } catch (std::exception& e) {
88101       {
88102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88103       };
88104     } catch (Dali::DaliException e) {
88105       {
88106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88107       };
88108     } catch (...) {
88109       {
88110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88111       };
88112     }
88113   }
88114
88115   jresult = SWIG_csharp_string_callback(result->c_str());
88116   return jresult;
88117 }
88118
88119
88120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
88121   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88122   Dali::Property::Map *arg2 = 0 ;
88123   Dali::Size arg3 ;
88124   Dali::Size *argp3 ;
88125
88126   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88127   arg2 = (Dali::Property::Map *)jarg2;
88128   if (!arg2) {
88129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
88130     return ;
88131   }
88132   argp3 = (Dali::Size *)jarg3;
88133   if (!argp3) {
88134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
88135     return ;
88136   }
88137   arg3 = *argp3;
88138   {
88139     try {
88140       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
88141     } catch (std::out_of_range& e) {
88142       {
88143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88144       };
88145     } catch (std::exception& e) {
88146       {
88147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88148       };
88149     } catch (Dali::DaliException e) {
88150       {
88151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88152       };
88153     } catch (...) {
88154       {
88155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88156       };
88157     }
88158   }
88159
88160 }
88161
88162
88163 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
88164   float jresult ;
88165   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88166   float arg2 ;
88167   float result;
88168
88169   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88170   arg2 = (float)jarg2;
88171   {
88172     try {
88173       result = (float)(arg1)->GetHeightForWidth(arg2);
88174     } catch (std::out_of_range& e) {
88175       {
88176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88177       };
88178     } catch (std::exception& e) {
88179       {
88180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88181       };
88182     } catch (Dali::DaliException e) {
88183       {
88184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88185       };
88186     } catch (...) {
88187       {
88188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88189       };
88190     }
88191   }
88192
88193   jresult = result;
88194   return jresult;
88195 }
88196
88197
88198 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
88199   float jresult ;
88200   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88201   float arg2 ;
88202   float result;
88203
88204   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88205   arg2 = (float)jarg2;
88206   {
88207     try {
88208       result = (float)(arg1)->GetWidthForHeight(arg2);
88209     } catch (std::out_of_range& e) {
88210       {
88211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88212       };
88213     } catch (std::exception& e) {
88214       {
88215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88216       };
88217     } catch (Dali::DaliException e) {
88218       {
88219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88220       };
88221     } catch (...) {
88222       {
88223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88224       };
88225     }
88226   }
88227
88228   jresult = result;
88229   return jresult;
88230 }
88231
88232
88233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
88234   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88235   Dali::Vector2 *arg2 = 0 ;
88236
88237   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88238   arg2 = (Dali::Vector2 *)jarg2;
88239   if (!arg2) {
88240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
88241     return ;
88242   }
88243   {
88244     try {
88245       (arg1)->GetNaturalSize(*arg2);
88246     } catch (std::out_of_range& e) {
88247       {
88248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88249       };
88250     } catch (std::exception& e) {
88251       {
88252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88253       };
88254     } catch (Dali::DaliException e) {
88255       {
88256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88257       };
88258     } catch (...) {
88259       {
88260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88261       };
88262     }
88263   }
88264
88265 }
88266
88267
88268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
88269   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88270   float arg2 ;
88271
88272   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88273   arg2 = (int)jarg2;
88274   {
88275     try {
88276       (arg1)->SetDepthIndex(arg2);
88277     } catch (std::out_of_range& e) {
88278       {
88279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88280       };
88281     } catch (std::exception& e) {
88282       {
88283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88284       };
88285     } catch (Dali::DaliException e) {
88286       {
88287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88288       };
88289     } catch (...) {
88290       {
88291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88292       };
88293     }
88294   }
88295
88296 }
88297
88298
88299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
88300   int jresult ;
88301   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88302   int result;
88303
88304   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88305   {
88306     try {
88307       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
88308     } catch (std::out_of_range& e) {
88309       {
88310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88311       };
88312     } catch (std::exception& e) {
88313       {
88314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88315       };
88316     } catch (Dali::DaliException e) {
88317       {
88318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88319       };
88320     } catch (...) {
88321       {
88322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88323       };
88324     }
88325   }
88326
88327   jresult = result;
88328   return jresult;
88329 }
88330
88331
88332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
88333   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88334   Dali::Property::Map *arg2 = 0 ;
88335
88336   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88337   arg2 = (Dali::Property::Map *)jarg2;
88338   if (!arg2) {
88339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
88340     return ;
88341   }
88342   {
88343     try {
88344       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
88345     } catch (std::out_of_range& e) {
88346       {
88347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88348       };
88349     } catch (std::exception& e) {
88350       {
88351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88352       };
88353     } catch (Dali::DaliException e) {
88354       {
88355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88356       };
88357     } catch (...) {
88358       {
88359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88360       };
88361     }
88362   }
88363
88364 }
88365
88366
88367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
88368   void * jresult ;
88369   Dali::Toolkit::VisualFactory result;
88370
88371   {
88372     try {
88373       result = Dali::Toolkit::VisualFactory::Get();
88374     } catch (std::out_of_range& e) {
88375       {
88376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88377       };
88378     } catch (std::exception& e) {
88379       {
88380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88381       };
88382     } catch (Dali::DaliException e) {
88383       {
88384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88385       };
88386     } catch (...) {
88387       {
88388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88389       };
88390     }
88391   }
88392
88393   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
88394   return jresult;
88395 }
88396
88397
88398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
88399   void * jresult ;
88400   Dali::Toolkit::VisualFactory *result = 0 ;
88401
88402   {
88403     try {
88404       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
88405     } catch (std::out_of_range& e) {
88406       {
88407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88408       };
88409     } catch (std::exception& e) {
88410       {
88411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88412       };
88413     } catch (Dali::DaliException e) {
88414       {
88415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88416       };
88417     } catch (...) {
88418       {
88419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88420       };
88421     }
88422   }
88423
88424   jresult = (void *)result;
88425   return jresult;
88426 }
88427
88428
88429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
88430   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
88431
88432   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
88433   {
88434     try {
88435       delete arg1;
88436     } catch (std::out_of_range& e) {
88437       {
88438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88439       };
88440     } catch (std::exception& e) {
88441       {
88442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88443       };
88444     } catch (Dali::DaliException e) {
88445       {
88446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88447       };
88448     } catch (...) {
88449       {
88450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88451       };
88452     }
88453   }
88454
88455 }
88456
88457
88458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
88459   void * jresult ;
88460   Dali::Toolkit::VisualFactory *arg1 = 0 ;
88461   Dali::Toolkit::VisualFactory *result = 0 ;
88462
88463   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
88464   if (!arg1) {
88465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
88466     return 0;
88467   }
88468   {
88469     try {
88470       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
88471     } catch (std::out_of_range& e) {
88472       {
88473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88474       };
88475     } catch (std::exception& e) {
88476       {
88477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88478       };
88479     } catch (Dali::DaliException e) {
88480       {
88481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88482       };
88483     } catch (...) {
88484       {
88485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88486       };
88487     }
88488   }
88489
88490   jresult = (void *)result;
88491   return jresult;
88492 }
88493
88494
88495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
88496   void * jresult ;
88497   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
88498   Dali::Toolkit::VisualFactory *arg2 = 0 ;
88499   Dali::Toolkit::VisualFactory *result = 0 ;
88500
88501   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
88502   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
88503   if (!arg2) {
88504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
88505     return 0;
88506   }
88507   {
88508     try {
88509       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
88510     } catch (std::out_of_range& e) {
88511       {
88512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88513       };
88514     } catch (std::exception& e) {
88515       {
88516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88517       };
88518     } catch (Dali::DaliException e) {
88519       {
88520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88521       };
88522     } catch (...) {
88523       {
88524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88525       };
88526     }
88527   }
88528
88529   jresult = (void *)result;
88530   return jresult;
88531 }
88532
88533
88534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
88535   void * jresult ;
88536   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
88537   Dali::Property::Map *arg2 = 0 ;
88538   Dali::Toolkit::Visual::Base result;
88539
88540   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
88541   arg2 = (Dali::Property::Map *)jarg2;
88542   if (!arg2) {
88543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
88544     return 0;
88545   }
88546   {
88547     try {
88548       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
88549     } catch (std::out_of_range& e) {
88550       {
88551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88552       };
88553     } catch (std::exception& e) {
88554       {
88555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88556       };
88557     } catch (Dali::DaliException e) {
88558       {
88559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88560       };
88561     } catch (...) {
88562       {
88563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88564       };
88565     }
88566   }
88567
88568   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
88569   return jresult;
88570 }
88571
88572
88573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
88574   void * jresult ;
88575   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
88576   std::string *arg2 = 0 ;
88577   Dali::ImageDimensions arg3 ;
88578   Dali::ImageDimensions *argp3 ;
88579   Dali::Toolkit::Visual::Base result;
88580
88581   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
88582   if (!jarg2) {
88583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88584     return 0;
88585   }
88586   std::string arg2_str(jarg2);
88587   arg2 = &arg2_str;
88588   argp3 = (Dali::ImageDimensions *)jarg3;
88589   if (!argp3) {
88590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
88591     return 0;
88592   }
88593   arg3 = *argp3;
88594   {
88595     try {
88596       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
88597     } catch (std::out_of_range& e) {
88598       {
88599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88600       };
88601     } catch (std::exception& e) {
88602       {
88603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88604       };
88605     } catch (Dali::DaliException e) {
88606       {
88607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88608       };
88609     } catch (...) {
88610       {
88611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88612       };
88613     }
88614   }
88615
88616   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
88617
88618   //argout typemap for const std::string&
88619
88620   return jresult;
88621 }
88622
88623
88624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
88625   void * jresult ;
88626   Dali::Toolkit::AsyncImageLoader *result = 0 ;
88627
88628   {
88629     try {
88630       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
88631     } catch (std::out_of_range& e) {
88632       {
88633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88634       };
88635     } catch (std::exception& e) {
88636       {
88637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88638       };
88639     } catch (Dali::DaliException e) {
88640       {
88641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88642       };
88643     } catch (...) {
88644       {
88645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88646       };
88647     }
88648   }
88649
88650   jresult = (void *)result;
88651   return jresult;
88652 }
88653
88654
88655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
88656   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88657
88658   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88659   {
88660     try {
88661       delete arg1;
88662     } catch (std::out_of_range& e) {
88663       {
88664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88665       };
88666     } catch (std::exception& e) {
88667       {
88668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88669       };
88670     } catch (Dali::DaliException e) {
88671       {
88672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88673       };
88674     } catch (...) {
88675       {
88676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88677       };
88678     }
88679   }
88680
88681 }
88682
88683
88684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
88685   void * jresult ;
88686   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
88687   Dali::Toolkit::AsyncImageLoader *result = 0 ;
88688
88689   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88690   if (!arg1) {
88691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
88692     return 0;
88693   }
88694   {
88695     try {
88696       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
88697     } catch (std::out_of_range& e) {
88698       {
88699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88700       };
88701     } catch (std::exception& e) {
88702       {
88703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88704       };
88705     } catch (Dali::DaliException e) {
88706       {
88707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88708       };
88709     } catch (...) {
88710       {
88711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88712       };
88713     }
88714   }
88715
88716   jresult = (void *)result;
88717   return jresult;
88718 }
88719
88720
88721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
88722   void * jresult ;
88723   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88724   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
88725   Dali::Toolkit::AsyncImageLoader *result = 0 ;
88726
88727   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88728   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
88729   if (!arg2) {
88730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
88731     return 0;
88732   }
88733   {
88734     try {
88735       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
88736     } catch (std::out_of_range& e) {
88737       {
88738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88739       };
88740     } catch (std::exception& e) {
88741       {
88742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88743       };
88744     } catch (Dali::DaliException e) {
88745       {
88746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88747       };
88748     } catch (...) {
88749       {
88750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88751       };
88752     }
88753   }
88754
88755   jresult = (void *)result;
88756   return jresult;
88757 }
88758
88759
88760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
88761   void * jresult ;
88762   Dali::Toolkit::AsyncImageLoader result;
88763
88764   {
88765     try {
88766       result = Dali::Toolkit::AsyncImageLoader::New();
88767     } catch (std::out_of_range& e) {
88768       {
88769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88770       };
88771     } catch (std::exception& e) {
88772       {
88773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88774       };
88775     } catch (Dali::DaliException e) {
88776       {
88777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88778       };
88779     } catch (...) {
88780       {
88781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88782       };
88783     }
88784   }
88785
88786   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
88787   return jresult;
88788 }
88789
88790
88791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
88792   void * jresult ;
88793   Dali::BaseHandle arg1 ;
88794   Dali::BaseHandle *argp1 ;
88795   Dali::Toolkit::AsyncImageLoader result;
88796
88797   argp1 = (Dali::BaseHandle *)jarg1;
88798   if (!argp1) {
88799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88800     return 0;
88801   }
88802   arg1 = *argp1;
88803   {
88804     try {
88805       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
88806     } catch (std::out_of_range& e) {
88807       {
88808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88809       };
88810     } catch (std::exception& e) {
88811       {
88812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88813       };
88814     } catch (Dali::DaliException e) {
88815       {
88816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88817       };
88818     } catch (...) {
88819       {
88820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88821       };
88822     }
88823   }
88824
88825   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
88826   return jresult;
88827 }
88828
88829
88830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
88831   unsigned int jresult ;
88832   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88833   std::string *arg2 = 0 ;
88834   uint32_t result;
88835
88836   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88837   if (!jarg2) {
88838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88839     return 0;
88840   }
88841   std::string arg2_str(jarg2);
88842   arg2 = &arg2_str;
88843   {
88844     try {
88845       result = (arg1)->Load((std::string const &)*arg2);
88846     } catch (std::out_of_range& e) {
88847       {
88848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88849       };
88850     } catch (std::exception& e) {
88851       {
88852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88853       };
88854     } catch (Dali::DaliException e) {
88855       {
88856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88857       };
88858     } catch (...) {
88859       {
88860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88861       };
88862     }
88863   }
88864
88865   jresult = result;
88866
88867   //argout typemap for const std::string&
88868
88869   return jresult;
88870 }
88871
88872
88873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
88874   unsigned int jresult ;
88875   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88876   std::string *arg2 = 0 ;
88877   Dali::ImageDimensions arg3 ;
88878   Dali::ImageDimensions *argp3 ;
88879   uint32_t result;
88880
88881   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88882   if (!jarg2) {
88883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88884     return 0;
88885   }
88886   std::string arg2_str(jarg2);
88887   arg2 = &arg2_str;
88888   argp3 = (Dali::ImageDimensions *)jarg3;
88889   if (!argp3) {
88890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
88891     return 0;
88892   }
88893   arg3 = *argp3;
88894   {
88895     try {
88896       result = (arg1)->Load((std::string const &)*arg2,arg3);
88897     } catch (std::out_of_range& e) {
88898       {
88899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88900       };
88901     } catch (std::exception& e) {
88902       {
88903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88904       };
88905     } catch (Dali::DaliException e) {
88906       {
88907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88908       };
88909     } catch (...) {
88910       {
88911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88912       };
88913     }
88914   }
88915
88916   jresult = result;
88917
88918   //argout typemap for const std::string&
88919
88920   return jresult;
88921 }
88922
88923
88924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
88925   unsigned int jresult ;
88926   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88927   std::string *arg2 = 0 ;
88928   Dali::ImageDimensions arg3 ;
88929   Dali::FittingMode::Type arg4 ;
88930   Dali::SamplingMode::Type arg5 ;
88931   bool arg6 ;
88932   Dali::ImageDimensions *argp3 ;
88933   uint32_t result;
88934
88935   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88936   if (!jarg2) {
88937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88938     return 0;
88939   }
88940   std::string arg2_str(jarg2);
88941   arg2 = &arg2_str;
88942   argp3 = (Dali::ImageDimensions *)jarg3;
88943   if (!argp3) {
88944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
88945     return 0;
88946   }
88947   arg3 = *argp3;
88948   arg4 = (Dali::FittingMode::Type)jarg4;
88949   arg5 = (Dali::SamplingMode::Type)jarg5;
88950   arg6 = jarg6 ? true : false;
88951   {
88952     try {
88953       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
88954     } catch (std::out_of_range& e) {
88955       {
88956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88957       };
88958     } catch (std::exception& e) {
88959       {
88960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88961       };
88962     } catch (Dali::DaliException e) {
88963       {
88964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88965       };
88966     } catch (...) {
88967       {
88968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88969       };
88970     }
88971   }
88972
88973   jresult = result;
88974
88975   //argout typemap for const std::string&
88976
88977   return jresult;
88978 }
88979
88980
88981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
88982   unsigned int jresult ;
88983   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
88984   uint32_t arg2 ;
88985   bool result;
88986
88987   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
88988   arg2 = (uint32_t)jarg2;
88989   {
88990     try {
88991       result = (bool)(arg1)->Cancel(arg2);
88992     } catch (std::out_of_range& e) {
88993       {
88994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88995       };
88996     } catch (std::exception& e) {
88997       {
88998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88999       };
89000     } catch (Dali::DaliException e) {
89001       {
89002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89003       };
89004     } catch (...) {
89005       {
89006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89007       };
89008     }
89009   }
89010
89011   jresult = result;
89012   return jresult;
89013 }
89014
89015
89016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
89017   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
89018
89019   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89020   {
89021     try {
89022       (arg1)->CancelAll();
89023     } catch (std::out_of_range& e) {
89024       {
89025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89026       };
89027     } catch (std::exception& e) {
89028       {
89029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89030       };
89031     } catch (Dali::DaliException e) {
89032       {
89033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89034       };
89035     } catch (...) {
89036       {
89037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89038       };
89039     }
89040   }
89041
89042 }
89043
89044
89045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
89046   void * jresult ;
89047   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
89048   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
89049
89050   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89051   {
89052     try {
89053       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
89054     } catch (std::out_of_range& e) {
89055       {
89056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89057       };
89058     } catch (std::exception& e) {
89059       {
89060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89061       };
89062     } catch (Dali::DaliException e) {
89063       {
89064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89065       };
89066     } catch (...) {
89067       {
89068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89069       };
89070     }
89071   }
89072
89073   jresult = (void *)result;
89074   return jresult;
89075 }
89076
89077
89078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
89079   void * jresult ;
89080   std::string *arg1 = 0 ;
89081   Dali::PixelData result;
89082
89083   if (!jarg1) {
89084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89085     return 0;
89086   }
89087   std::string arg1_str(jarg1);
89088   arg1 = &arg1_str;
89089   {
89090     try {
89091       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
89092     } catch (std::out_of_range& e) {
89093       {
89094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89095       };
89096     } catch (std::exception& e) {
89097       {
89098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89099       };
89100     } catch (Dali::DaliException e) {
89101       {
89102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89103       };
89104     } catch (...) {
89105       {
89106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89107       };
89108     }
89109   }
89110
89111   jresult = new Dali::PixelData((const Dali::PixelData &)result);
89112
89113   //argout typemap for const std::string&
89114
89115   return jresult;
89116 }
89117
89118
89119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
89120   void * jresult ;
89121   std::string *arg1 = 0 ;
89122   Dali::ImageDimensions arg2 ;
89123   Dali::ImageDimensions *argp2 ;
89124   Dali::PixelData result;
89125
89126   if (!jarg1) {
89127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89128     return 0;
89129   }
89130   std::string arg1_str(jarg1);
89131   arg1 = &arg1_str;
89132   argp2 = (Dali::ImageDimensions *)jarg2;
89133   if (!argp2) {
89134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
89135     return 0;
89136   }
89137   arg2 = *argp2;
89138   {
89139     try {
89140       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
89141     } catch (std::out_of_range& e) {
89142       {
89143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89144       };
89145     } catch (std::exception& e) {
89146       {
89147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89148       };
89149     } catch (Dali::DaliException e) {
89150       {
89151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89152       };
89153     } catch (...) {
89154       {
89155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89156       };
89157     }
89158   }
89159
89160   jresult = new Dali::PixelData((const Dali::PixelData &)result);
89161
89162   //argout typemap for const std::string&
89163
89164   return jresult;
89165 }
89166
89167
89168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
89169   void * jresult ;
89170   std::string *arg1 = 0 ;
89171   Dali::ImageDimensions arg2 ;
89172   Dali::FittingMode::Type arg3 ;
89173   Dali::SamplingMode::Type arg4 ;
89174   bool arg5 ;
89175   Dali::ImageDimensions *argp2 ;
89176   Dali::PixelData result;
89177
89178   if (!jarg1) {
89179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89180     return 0;
89181   }
89182   std::string arg1_str(jarg1);
89183   arg1 = &arg1_str;
89184   argp2 = (Dali::ImageDimensions *)jarg2;
89185   if (!argp2) {
89186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
89187     return 0;
89188   }
89189   arg2 = *argp2;
89190   arg3 = (Dali::FittingMode::Type)jarg3;
89191   arg4 = (Dali::SamplingMode::Type)jarg4;
89192   arg5 = jarg5 ? true : false;
89193   {
89194     try {
89195       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
89196     } catch (std::out_of_range& e) {
89197       {
89198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89199       };
89200     } catch (std::exception& e) {
89201       {
89202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89203       };
89204     } catch (Dali::DaliException e) {
89205       {
89206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89207       };
89208     } catch (...) {
89209       {
89210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89211       };
89212     }
89213   }
89214
89215   jresult = new Dali::PixelData((const Dali::PixelData &)result);
89216
89217   //argout typemap for const std::string&
89218
89219   return jresult;
89220 }
89221
89222
89223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
89224   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
89225
89226   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
89227   {
89228     try {
89229       delete arg1;
89230     } catch (std::out_of_range& e) {
89231       {
89232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89233       };
89234     } catch (std::exception& e) {
89235       {
89236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89237       };
89238     } catch (Dali::DaliException e) {
89239       {
89240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89241       };
89242     } catch (...) {
89243       {
89244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89245       };
89246     }
89247   }
89248
89249 }
89250
89251
89252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
89253   void * jresult ;
89254   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
89255   Dali::Actor arg2 ;
89256   Dali::Actor arg3 ;
89257   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
89258   Dali::Actor *argp2 ;
89259   Dali::Actor *argp3 ;
89260   Dali::Actor result;
89261
89262   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
89263   argp2 = (Dali::Actor *)jarg2;
89264   if (!argp2) {
89265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89266     return 0;
89267   }
89268   arg2 = *argp2;
89269   argp3 = (Dali::Actor *)jarg3;
89270   if (!argp3) {
89271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89272     return 0;
89273   }
89274   arg3 = *argp3;
89275   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
89276   {
89277     try {
89278       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
89279     } catch (std::out_of_range& e) {
89280       {
89281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89282       };
89283     } catch (std::exception& e) {
89284       {
89285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89286       };
89287     } catch (Dali::DaliException e) {
89288       {
89289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89290       };
89291     } catch (...) {
89292       {
89293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89294       };
89295     }
89296   }
89297
89298   jresult = new Dali::Actor((const Dali::Actor &)result);
89299   return jresult;
89300 }
89301
89302
89303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
89304   void * jresult ;
89305   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
89306
89307   {
89308     try {
89309       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
89310     } catch (std::out_of_range& e) {
89311       {
89312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89313       };
89314     } catch (std::exception& e) {
89315       {
89316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89317       };
89318     } catch (Dali::DaliException e) {
89319       {
89320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89321       };
89322     } catch (...) {
89323       {
89324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89325       };
89326     }
89327   }
89328
89329   jresult = (void *)result;
89330   return jresult;
89331 }
89332
89333
89334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
89335   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
89336   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
89337   if (director) {
89338     director->swig_connect_director(callback0);
89339   }
89340 }
89341
89342
89343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
89344   KeyboardFocusManager arg1 ;
89345   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
89346   KeyboardFocusManager *argp1 ;
89347
89348   argp1 = (KeyboardFocusManager *)jarg1;
89349   if (!argp1) {
89350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
89351     return ;
89352   }
89353   arg1 = *argp1;
89354   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
89355   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
89356   {
89357     try {
89358       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
89359     } catch (std::out_of_range& e) {
89360       {
89361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89362       };
89363     } catch (std::exception& e) {
89364       {
89365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89366       };
89367     } catch (Dali::DaliException e) {
89368       {
89369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89370       };
89371     } catch (...) {
89372       {
89373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89374       };
89375     }
89376   }
89377
89378 }
89379
89380
89381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
89382   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89383
89384   arg1 = (std::vector< unsigned int > *)jarg1;
89385   {
89386     try {
89387       (arg1)->clear();
89388     } catch (std::out_of_range& e) {
89389       {
89390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89391       };
89392     } catch (std::exception& e) {
89393       {
89394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89395       };
89396     } catch (Dali::DaliException e) {
89397       {
89398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89399       };
89400     } catch (...) {
89401       {
89402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89403       };
89404     }
89405   }
89406
89407 }
89408
89409
89410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
89411   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89412   unsigned int *arg2 = 0 ;
89413   unsigned int temp2 ;
89414
89415   arg1 = (std::vector< unsigned int > *)jarg1;
89416   temp2 = (unsigned int)jarg2;
89417   arg2 = &temp2;
89418   {
89419     try {
89420       (arg1)->push_back((unsigned int const &)*arg2);
89421     } catch (std::out_of_range& e) {
89422       {
89423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89424       };
89425     } catch (std::exception& e) {
89426       {
89427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89428       };
89429     } catch (Dali::DaliException e) {
89430       {
89431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89432       };
89433     } catch (...) {
89434       {
89435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89436       };
89437     }
89438   }
89439
89440 }
89441
89442
89443 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
89444   unsigned long jresult ;
89445   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89446   std::vector< unsigned int >::size_type result;
89447
89448   arg1 = (std::vector< unsigned int > *)jarg1;
89449   {
89450     try {
89451       result = ((std::vector< unsigned int > const *)arg1)->size();
89452     } catch (std::out_of_range& e) {
89453       {
89454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89455       };
89456     } catch (std::exception& e) {
89457       {
89458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89459       };
89460     } catch (Dali::DaliException e) {
89461       {
89462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89463       };
89464     } catch (...) {
89465       {
89466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89467       };
89468     }
89469   }
89470
89471   jresult = (unsigned long)result;
89472   return jresult;
89473 }
89474
89475
89476 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
89477   unsigned long jresult ;
89478   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89479   std::vector< unsigned int >::size_type result;
89480
89481   arg1 = (std::vector< unsigned int > *)jarg1;
89482   {
89483     try {
89484       result = ((std::vector< unsigned int > const *)arg1)->capacity();
89485     } catch (std::out_of_range& e) {
89486       {
89487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89488       };
89489     } catch (std::exception& e) {
89490       {
89491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89492       };
89493     } catch (Dali::DaliException e) {
89494       {
89495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89496       };
89497     } catch (...) {
89498       {
89499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89500       };
89501     }
89502   }
89503
89504   jresult = (unsigned long)result;
89505   return jresult;
89506 }
89507
89508
89509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
89510   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89511   std::vector< unsigned int >::size_type arg2 ;
89512
89513   arg1 = (std::vector< unsigned int > *)jarg1;
89514   arg2 = (std::vector< unsigned int >::size_type)jarg2;
89515   {
89516     try {
89517       (arg1)->reserve(arg2);
89518     } catch (std::out_of_range& e) {
89519       {
89520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89521       };
89522     } catch (std::exception& e) {
89523       {
89524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89525       };
89526     } catch (Dali::DaliException e) {
89527       {
89528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89529       };
89530     } catch (...) {
89531       {
89532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89533       };
89534     }
89535   }
89536
89537 }
89538
89539
89540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
89541   void * jresult ;
89542   std::vector< unsigned int > *result = 0 ;
89543
89544   {
89545     try {
89546       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
89547     } catch (std::out_of_range& e) {
89548       {
89549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89550       };
89551     } catch (std::exception& e) {
89552       {
89553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89554       };
89555     } catch (Dali::DaliException e) {
89556       {
89557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89558       };
89559     } catch (...) {
89560       {
89561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89562       };
89563     }
89564   }
89565
89566   jresult = (void *)result;
89567   return jresult;
89568 }
89569
89570
89571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
89572   void * jresult ;
89573   std::vector< unsigned int > *arg1 = 0 ;
89574   std::vector< unsigned int > *result = 0 ;
89575
89576   arg1 = (std::vector< unsigned int > *)jarg1;
89577   if (!arg1) {
89578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
89579     return 0;
89580   }
89581   {
89582     try {
89583       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
89584     } catch (std::out_of_range& e) {
89585       {
89586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89587       };
89588     } catch (std::exception& e) {
89589       {
89590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89591       };
89592     } catch (Dali::DaliException e) {
89593       {
89594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89595       };
89596     } catch (...) {
89597       {
89598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89599       };
89600     }
89601   }
89602
89603   jresult = (void *)result;
89604   return jresult;
89605 }
89606
89607
89608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
89609   void * jresult ;
89610   int arg1 ;
89611   std::vector< unsigned int > *result = 0 ;
89612
89613   arg1 = (int)jarg1;
89614   {
89615     try {
89616       try {
89617         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
89618       }
89619       catch(std::out_of_range &_e) {
89620         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89621         return 0;
89622       }
89623
89624     } catch (std::out_of_range& e) {
89625       {
89626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89627       };
89628     } catch (std::exception& e) {
89629       {
89630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89631       };
89632     } catch (Dali::DaliException e) {
89633       {
89634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89635       };
89636     } catch (...) {
89637       {
89638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89639       };
89640     }
89641   }
89642
89643   jresult = (void *)result;
89644   return jresult;
89645 }
89646
89647
89648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
89649   unsigned int jresult ;
89650   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89651   int arg2 ;
89652   unsigned int result;
89653
89654   arg1 = (std::vector< unsigned int > *)jarg1;
89655   arg2 = (int)jarg2;
89656   {
89657     try {
89658       try {
89659         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
89660       }
89661       catch(std::out_of_range &_e) {
89662         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89663         return 0;
89664       }
89665
89666     } catch (std::out_of_range& e) {
89667       {
89668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89669       };
89670     } catch (std::exception& e) {
89671       {
89672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89673       };
89674     } catch (Dali::DaliException e) {
89675       {
89676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89677       };
89678     } catch (...) {
89679       {
89680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89681       };
89682     }
89683   }
89684
89685   jresult = result;
89686   return jresult;
89687 }
89688
89689
89690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
89691   unsigned int jresult ;
89692   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89693   int arg2 ;
89694   unsigned int *result = 0 ;
89695
89696   arg1 = (std::vector< unsigned int > *)jarg1;
89697   arg2 = (int)jarg2;
89698   {
89699     try {
89700       try {
89701         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
89702       }
89703       catch(std::out_of_range &_e) {
89704         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89705         return 0;
89706       }
89707
89708     } catch (std::out_of_range& e) {
89709       {
89710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89711       };
89712     } catch (std::exception& e) {
89713       {
89714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89715       };
89716     } catch (Dali::DaliException e) {
89717       {
89718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89719       };
89720     } catch (...) {
89721       {
89722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89723       };
89724     }
89725   }
89726
89727   jresult = *result;
89728   return jresult;
89729 }
89730
89731
89732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
89733   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89734   int arg2 ;
89735   unsigned int *arg3 = 0 ;
89736   unsigned int temp3 ;
89737
89738   arg1 = (std::vector< unsigned int > *)jarg1;
89739   arg2 = (int)jarg2;
89740   temp3 = (unsigned int)jarg3;
89741   arg3 = &temp3;
89742   {
89743     try {
89744       try {
89745         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
89746       }
89747       catch(std::out_of_range &_e) {
89748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89749         return ;
89750       }
89751
89752     } catch (std::out_of_range& e) {
89753       {
89754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89755       };
89756     } catch (std::exception& e) {
89757       {
89758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89759       };
89760     } catch (Dali::DaliException e) {
89761       {
89762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89763       };
89764     } catch (...) {
89765       {
89766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89767       };
89768     }
89769   }
89770
89771 }
89772
89773
89774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
89775   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89776   std::vector< unsigned int > *arg2 = 0 ;
89777
89778   arg1 = (std::vector< unsigned int > *)jarg1;
89779   arg2 = (std::vector< unsigned int > *)jarg2;
89780   if (!arg2) {
89781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
89782     return ;
89783   }
89784   {
89785     try {
89786       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
89787     } catch (std::out_of_range& e) {
89788       {
89789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89790       };
89791     } catch (std::exception& e) {
89792       {
89793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89794       };
89795     } catch (Dali::DaliException e) {
89796       {
89797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89798       };
89799     } catch (...) {
89800       {
89801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89802       };
89803     }
89804   }
89805
89806 }
89807
89808
89809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89810   void * jresult ;
89811   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89812   int arg2 ;
89813   int arg3 ;
89814   std::vector< unsigned int > *result = 0 ;
89815
89816   arg1 = (std::vector< unsigned int > *)jarg1;
89817   arg2 = (int)jarg2;
89818   arg3 = (int)jarg3;
89819   {
89820     try {
89821       try {
89822         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
89823       }
89824       catch(std::out_of_range &_e) {
89825         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89826         return 0;
89827       }
89828       catch(std::invalid_argument &_e) {
89829         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89830         return 0;
89831       }
89832
89833     } catch (std::out_of_range& e) {
89834       {
89835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89836       };
89837     } catch (std::exception& e) {
89838       {
89839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89840       };
89841     } catch (Dali::DaliException e) {
89842       {
89843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89844       };
89845     } catch (...) {
89846       {
89847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89848       };
89849     }
89850   }
89851
89852   jresult = (void *)result;
89853   return jresult;
89854 }
89855
89856
89857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
89858   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89859   int arg2 ;
89860   unsigned int *arg3 = 0 ;
89861   unsigned int temp3 ;
89862
89863   arg1 = (std::vector< unsigned int > *)jarg1;
89864   arg2 = (int)jarg2;
89865   temp3 = (unsigned int)jarg3;
89866   arg3 = &temp3;
89867   {
89868     try {
89869       try {
89870         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
89871       }
89872       catch(std::out_of_range &_e) {
89873         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89874         return ;
89875       }
89876
89877     } catch (std::out_of_range& e) {
89878       {
89879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89880       };
89881     } catch (std::exception& e) {
89882       {
89883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89884       };
89885     } catch (Dali::DaliException e) {
89886       {
89887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89888       };
89889     } catch (...) {
89890       {
89891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89892       };
89893     }
89894   }
89895
89896 }
89897
89898
89899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89900   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89901   int arg2 ;
89902   std::vector< unsigned int > *arg3 = 0 ;
89903
89904   arg1 = (std::vector< unsigned int > *)jarg1;
89905   arg2 = (int)jarg2;
89906   arg3 = (std::vector< unsigned int > *)jarg3;
89907   if (!arg3) {
89908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
89909     return ;
89910   }
89911   {
89912     try {
89913       try {
89914         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
89915       }
89916       catch(std::out_of_range &_e) {
89917         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89918         return ;
89919       }
89920
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_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
89944   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89945   int arg2 ;
89946
89947   arg1 = (std::vector< unsigned int > *)jarg1;
89948   arg2 = (int)jarg2;
89949   {
89950     try {
89951       try {
89952         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
89953       }
89954       catch(std::out_of_range &_e) {
89955         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89956         return ;
89957       }
89958
89959     } catch (std::out_of_range& e) {
89960       {
89961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89962       };
89963     } catch (std::exception& e) {
89964       {
89965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89966       };
89967     } catch (Dali::DaliException e) {
89968       {
89969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89970       };
89971     } catch (...) {
89972       {
89973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89974       };
89975     }
89976   }
89977
89978 }
89979
89980
89981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89982   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
89983   int arg2 ;
89984   int arg3 ;
89985
89986   arg1 = (std::vector< unsigned int > *)jarg1;
89987   arg2 = (int)jarg2;
89988   arg3 = (int)jarg3;
89989   {
89990     try {
89991       try {
89992         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
89993       }
89994       catch(std::out_of_range &_e) {
89995         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89996         return ;
89997       }
89998       catch(std::invalid_argument &_e) {
89999         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90000         return ;
90001       }
90002
90003     } catch (std::out_of_range& e) {
90004       {
90005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90006       };
90007     } catch (std::exception& e) {
90008       {
90009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90010       };
90011     } catch (Dali::DaliException e) {
90012       {
90013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90014       };
90015     } catch (...) {
90016       {
90017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90018       };
90019     }
90020   }
90021
90022 }
90023
90024
90025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
90026   void * jresult ;
90027   unsigned int *arg1 = 0 ;
90028   int arg2 ;
90029   unsigned int temp1 ;
90030   std::vector< unsigned int > *result = 0 ;
90031
90032   temp1 = (unsigned int)jarg1;
90033   arg1 = &temp1;
90034   arg2 = (int)jarg2;
90035   {
90036     try {
90037       try {
90038         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
90039       }
90040       catch(std::out_of_range &_e) {
90041         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90042         return 0;
90043       }
90044
90045     } catch (std::out_of_range& e) {
90046       {
90047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90048       };
90049     } catch (std::exception& e) {
90050       {
90051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90052       };
90053     } catch (Dali::DaliException e) {
90054       {
90055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90056       };
90057     } catch (...) {
90058       {
90059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90060       };
90061     }
90062   }
90063
90064   jresult = (void *)result;
90065   return jresult;
90066 }
90067
90068
90069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
90070   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90071
90072   arg1 = (std::vector< unsigned int > *)jarg1;
90073   {
90074     try {
90075       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
90076     } catch (std::out_of_range& e) {
90077       {
90078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90079       };
90080     } catch (std::exception& e) {
90081       {
90082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90083       };
90084     } catch (Dali::DaliException e) {
90085       {
90086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90087       };
90088     } catch (...) {
90089       {
90090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90091       };
90092     }
90093   }
90094
90095 }
90096
90097
90098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
90099   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90100   int arg2 ;
90101   int arg3 ;
90102
90103   arg1 = (std::vector< unsigned int > *)jarg1;
90104   arg2 = (int)jarg2;
90105   arg3 = (int)jarg3;
90106   {
90107     try {
90108       try {
90109         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
90110       }
90111       catch(std::out_of_range &_e) {
90112         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90113         return ;
90114       }
90115       catch(std::invalid_argument &_e) {
90116         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90117         return ;
90118       }
90119
90120     } catch (std::out_of_range& e) {
90121       {
90122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90123       };
90124     } catch (std::exception& e) {
90125       {
90126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90127       };
90128     } catch (Dali::DaliException e) {
90129       {
90130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90131       };
90132     } catch (...) {
90133       {
90134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90135       };
90136     }
90137   }
90138
90139 }
90140
90141
90142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
90143   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90144   int arg2 ;
90145   std::vector< unsigned int > *arg3 = 0 ;
90146
90147   arg1 = (std::vector< unsigned int > *)jarg1;
90148   arg2 = (int)jarg2;
90149   arg3 = (std::vector< unsigned int > *)jarg3;
90150   if (!arg3) {
90151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
90152     return ;
90153   }
90154   {
90155     try {
90156       try {
90157         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
90158       }
90159       catch(std::out_of_range &_e) {
90160         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90161         return ;
90162       }
90163
90164     } catch (std::out_of_range& e) {
90165       {
90166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90167       };
90168     } catch (std::exception& e) {
90169       {
90170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90171       };
90172     } catch (Dali::DaliException e) {
90173       {
90174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90175       };
90176     } catch (...) {
90177       {
90178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90179       };
90180     }
90181   }
90182
90183 }
90184
90185
90186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
90187   unsigned int jresult ;
90188   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90189   unsigned int *arg2 = 0 ;
90190   unsigned int temp2 ;
90191   bool result;
90192
90193   arg1 = (std::vector< unsigned int > *)jarg1;
90194   temp2 = (unsigned int)jarg2;
90195   arg2 = &temp2;
90196   {
90197     try {
90198       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
90199     } catch (std::out_of_range& e) {
90200       {
90201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90202       };
90203     } catch (std::exception& e) {
90204       {
90205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90206       };
90207     } catch (Dali::DaliException e) {
90208       {
90209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90210       };
90211     } catch (...) {
90212       {
90213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90214       };
90215     }
90216   }
90217
90218   jresult = result;
90219   return jresult;
90220 }
90221
90222
90223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
90224   int jresult ;
90225   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90226   unsigned int *arg2 = 0 ;
90227   unsigned int temp2 ;
90228   int result;
90229
90230   arg1 = (std::vector< unsigned int > *)jarg1;
90231   temp2 = (unsigned int)jarg2;
90232   arg2 = &temp2;
90233   {
90234     try {
90235       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
90236     } catch (std::out_of_range& e) {
90237       {
90238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90239       };
90240     } catch (std::exception& e) {
90241       {
90242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90243       };
90244     } catch (Dali::DaliException e) {
90245       {
90246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90247       };
90248     } catch (...) {
90249       {
90250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90251       };
90252     }
90253   }
90254
90255   jresult = result;
90256   return jresult;
90257 }
90258
90259
90260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
90261   int jresult ;
90262   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90263   unsigned int *arg2 = 0 ;
90264   unsigned int temp2 ;
90265   int result;
90266
90267   arg1 = (std::vector< unsigned int > *)jarg1;
90268   temp2 = (unsigned int)jarg2;
90269   arg2 = &temp2;
90270   {
90271     try {
90272       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
90273     } catch (std::out_of_range& e) {
90274       {
90275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90276       };
90277     } catch (std::exception& e) {
90278       {
90279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90280       };
90281     } catch (Dali::DaliException e) {
90282       {
90283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90284       };
90285     } catch (...) {
90286       {
90287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90288       };
90289     }
90290   }
90291
90292   jresult = result;
90293   return jresult;
90294 }
90295
90296
90297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
90298   unsigned int jresult ;
90299   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90300   unsigned int *arg2 = 0 ;
90301   unsigned int temp2 ;
90302   bool result;
90303
90304   arg1 = (std::vector< unsigned int > *)jarg1;
90305   temp2 = (unsigned int)jarg2;
90306   arg2 = &temp2;
90307   {
90308     try {
90309       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
90310     } catch (std::out_of_range& e) {
90311       {
90312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90313       };
90314     } catch (std::exception& e) {
90315       {
90316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90317       };
90318     } catch (Dali::DaliException e) {
90319       {
90320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90321       };
90322     } catch (...) {
90323       {
90324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90325       };
90326     }
90327   }
90328
90329   jresult = result;
90330   return jresult;
90331 }
90332
90333
90334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
90335   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90336
90337   arg1 = (std::vector< unsigned int > *)jarg1;
90338   {
90339     try {
90340       delete arg1;
90341     } catch (std::out_of_range& e) {
90342       {
90343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90344       };
90345     } catch (std::exception& e) {
90346       {
90347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90348       };
90349     } catch (Dali::DaliException e) {
90350       {
90351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90352       };
90353     } catch (...) {
90354       {
90355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90356       };
90357     }
90358   }
90359
90360 }
90361
90362
90363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
90364   void * jresult ;
90365   std::pair< unsigned int,Dali::Actor > *result = 0 ;
90366
90367   {
90368     try {
90369       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
90370     } catch (std::out_of_range& e) {
90371       {
90372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90373       };
90374     } catch (std::exception& e) {
90375       {
90376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90377       };
90378     } catch (Dali::DaliException e) {
90379       {
90380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90381       };
90382     } catch (...) {
90383       {
90384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90385       };
90386     }
90387   }
90388
90389   jresult = (void *)result;
90390   return jresult;
90391 }
90392
90393
90394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
90395   void * jresult ;
90396   unsigned int arg1 ;
90397   Dali::Actor arg2 ;
90398   Dali::Actor *argp2 ;
90399   std::pair< unsigned int,Dali::Actor > *result = 0 ;
90400
90401   arg1 = (unsigned int)jarg1;
90402   argp2 = (Dali::Actor *)jarg2;
90403   if (!argp2) {
90404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90405     return 0;
90406   }
90407   arg2 = *argp2;
90408   {
90409     try {
90410       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
90411     } catch (std::out_of_range& e) {
90412       {
90413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90414       };
90415     } catch (std::exception& e) {
90416       {
90417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90418       };
90419     } catch (Dali::DaliException e) {
90420       {
90421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90422       };
90423     } catch (...) {
90424       {
90425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90426       };
90427     }
90428   }
90429
90430   jresult = (void *)result;
90431   return jresult;
90432 }
90433
90434
90435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
90436   void * jresult ;
90437   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
90438   std::pair< unsigned int,Dali::Actor > *result = 0 ;
90439
90440   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
90441   if (!arg1) {
90442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
90443     return 0;
90444   }
90445   {
90446     try {
90447       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
90448     } catch (std::out_of_range& e) {
90449       {
90450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90451       };
90452     } catch (std::exception& e) {
90453       {
90454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90455       };
90456     } catch (Dali::DaliException e) {
90457       {
90458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90459       };
90460     } catch (...) {
90461       {
90462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90463       };
90464     }
90465   }
90466
90467   jresult = (void *)result;
90468   return jresult;
90469 }
90470
90471
90472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
90473   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
90474   unsigned int arg2 ;
90475
90476   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
90477   arg2 = (unsigned int)jarg2;
90478   if (arg1) (arg1)->first = arg2;
90479 }
90480
90481
90482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
90483   unsigned int jresult ;
90484   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
90485   unsigned int result;
90486
90487   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
90488   result = (unsigned int) ((arg1)->first);
90489   jresult = result;
90490   return jresult;
90491 }
90492
90493
90494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
90495   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
90496   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
90497
90498   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
90499   arg2 = (Dali::Actor *)jarg2;
90500   if (arg1) (arg1)->second = *arg2;
90501 }
90502
90503
90504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
90505   void * jresult ;
90506   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
90507   Dali::Actor *result = 0 ;
90508
90509   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
90510   result = (Dali::Actor *)& ((arg1)->second);
90511   jresult = (void *)result;
90512   return jresult;
90513 }
90514
90515
90516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
90517   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
90518
90519   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
90520   {
90521     try {
90522       delete arg1;
90523     } catch (std::out_of_range& e) {
90524       {
90525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90526       };
90527     } catch (std::exception& e) {
90528       {
90529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90530       };
90531     } catch (Dali::DaliException e) {
90532       {
90533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90534       };
90535     } catch (...) {
90536       {
90537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90538       };
90539     }
90540   }
90541
90542 }
90543
90544
90545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
90546   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90547
90548   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90549   {
90550     try {
90551       (arg1)->clear();
90552     } catch (std::out_of_range& e) {
90553       {
90554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90555       };
90556     } catch (std::exception& e) {
90557       {
90558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90559       };
90560     } catch (Dali::DaliException e) {
90561       {
90562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90563       };
90564     } catch (...) {
90565       {
90566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90567       };
90568     }
90569   }
90570
90571 }
90572
90573
90574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
90575   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90576   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
90577
90578   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90579   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
90580   if (!arg2) {
90581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
90582     return ;
90583   }
90584   {
90585     try {
90586       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
90587     } catch (std::out_of_range& e) {
90588       {
90589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90590       };
90591     } catch (std::exception& e) {
90592       {
90593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90594       };
90595     } catch (Dali::DaliException e) {
90596       {
90597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90598       };
90599     } catch (...) {
90600       {
90601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90602       };
90603     }
90604   }
90605
90606 }
90607
90608
90609 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
90610   unsigned long jresult ;
90611   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90612   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
90613
90614   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90615   {
90616     try {
90617       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
90618     } catch (std::out_of_range& e) {
90619       {
90620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90621       };
90622     } catch (std::exception& e) {
90623       {
90624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90625       };
90626     } catch (Dali::DaliException e) {
90627       {
90628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90629       };
90630     } catch (...) {
90631       {
90632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90633       };
90634     }
90635   }
90636
90637   jresult = (unsigned long)result;
90638   return jresult;
90639 }
90640
90641
90642 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
90643   unsigned long jresult ;
90644   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90645   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
90646
90647   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90648   {
90649     try {
90650       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
90651     } catch (std::out_of_range& e) {
90652       {
90653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90654       };
90655     } catch (std::exception& e) {
90656       {
90657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90658       };
90659     } catch (Dali::DaliException e) {
90660       {
90661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90662       };
90663     } catch (...) {
90664       {
90665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90666       };
90667     }
90668   }
90669
90670   jresult = (unsigned long)result;
90671   return jresult;
90672 }
90673
90674
90675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
90676   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90677   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
90678
90679   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90680   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
90681   {
90682     try {
90683       (arg1)->reserve(arg2);
90684     } catch (std::out_of_range& e) {
90685       {
90686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90687       };
90688     } catch (std::exception& e) {
90689       {
90690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90691       };
90692     } catch (Dali::DaliException e) {
90693       {
90694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90695       };
90696     } catch (...) {
90697       {
90698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90699       };
90700     }
90701   }
90702
90703 }
90704
90705
90706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
90707   void * jresult ;
90708   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
90709
90710   {
90711     try {
90712       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
90713     } catch (std::out_of_range& e) {
90714       {
90715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90716       };
90717     } catch (std::exception& e) {
90718       {
90719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90720       };
90721     } catch (Dali::DaliException e) {
90722       {
90723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90724       };
90725     } catch (...) {
90726       {
90727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90728       };
90729     }
90730   }
90731
90732   jresult = (void *)result;
90733   return jresult;
90734 }
90735
90736
90737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
90738   void * jresult ;
90739   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
90740   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
90741
90742   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90743   if (!arg1) {
90744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
90745     return 0;
90746   }
90747   {
90748     try {
90749       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);
90750     } catch (std::out_of_range& e) {
90751       {
90752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90753       };
90754     } catch (std::exception& e) {
90755       {
90756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90757       };
90758     } catch (Dali::DaliException e) {
90759       {
90760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90761       };
90762     } catch (...) {
90763       {
90764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90765       };
90766     }
90767   }
90768
90769   jresult = (void *)result;
90770   return jresult;
90771 }
90772
90773
90774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
90775   void * jresult ;
90776   int arg1 ;
90777   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
90778
90779   arg1 = (int)jarg1;
90780   {
90781     try {
90782       try {
90783         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);
90784       }
90785       catch(std::out_of_range &_e) {
90786         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90787         return 0;
90788       }
90789
90790     } catch (std::out_of_range& e) {
90791       {
90792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90793       };
90794     } catch (std::exception& e) {
90795       {
90796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90797       };
90798     } catch (Dali::DaliException e) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90801       };
90802     } catch (...) {
90803       {
90804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90805       };
90806     }
90807   }
90808
90809   jresult = (void *)result;
90810   return jresult;
90811 }
90812
90813
90814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
90815   void * jresult ;
90816   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90817   int arg2 ;
90818   std::pair< unsigned int,Dali::Actor > result;
90819
90820   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90821   arg2 = (int)jarg2;
90822   {
90823     try {
90824       try {
90825         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
90826       }
90827       catch(std::out_of_range &_e) {
90828         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90829         return 0;
90830       }
90831
90832     } catch (std::out_of_range& e) {
90833       {
90834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90835       };
90836     } catch (std::exception& e) {
90837       {
90838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90839       };
90840     } catch (Dali::DaliException e) {
90841       {
90842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90843       };
90844     } catch (...) {
90845       {
90846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90847       };
90848     }
90849   }
90850
90851   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
90852   return jresult;
90853 }
90854
90855
90856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
90857   void * jresult ;
90858   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90859   int arg2 ;
90860   std::pair< unsigned int,Dali::Actor > *result = 0 ;
90861
90862   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90863   arg2 = (int)jarg2;
90864   {
90865     try {
90866       try {
90867         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
90868       }
90869       catch(std::out_of_range &_e) {
90870         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90871         return 0;
90872       }
90873
90874     } catch (std::out_of_range& e) {
90875       {
90876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90877       };
90878     } catch (std::exception& e) {
90879       {
90880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90881       };
90882     } catch (Dali::DaliException e) {
90883       {
90884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90885       };
90886     } catch (...) {
90887       {
90888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90889       };
90890     }
90891   }
90892
90893   jresult = (void *)result;
90894   return jresult;
90895 }
90896
90897
90898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
90899   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90900   int arg2 ;
90901   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
90902
90903   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90904   arg2 = (int)jarg2;
90905   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
90906   if (!arg3) {
90907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
90908     return ;
90909   }
90910   {
90911     try {
90912       try {
90913         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);
90914       }
90915       catch(std::out_of_range &_e) {
90916         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90917         return ;
90918       }
90919
90920     } catch (std::out_of_range& e) {
90921       {
90922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90923       };
90924     } catch (std::exception& e) {
90925       {
90926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90927       };
90928     } catch (Dali::DaliException e) {
90929       {
90930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90931       };
90932     } catch (...) {
90933       {
90934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90935       };
90936     }
90937   }
90938
90939 }
90940
90941
90942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
90943   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90944   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
90945
90946   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90947   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
90948   if (!arg2) {
90949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
90950     return ;
90951   }
90952   {
90953     try {
90954       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);
90955     } catch (std::out_of_range& e) {
90956       {
90957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90958       };
90959     } catch (std::exception& e) {
90960       {
90961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90962       };
90963     } catch (Dali::DaliException e) {
90964       {
90965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90966       };
90967     } catch (...) {
90968       {
90969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90970       };
90971     }
90972   }
90973
90974 }
90975
90976
90977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
90978   void * jresult ;
90979   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
90980   int arg2 ;
90981   int arg3 ;
90982   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
90983
90984   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
90985   arg2 = (int)jarg2;
90986   arg3 = (int)jarg3;
90987   {
90988     try {
90989       try {
90990         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);
90991       }
90992       catch(std::out_of_range &_e) {
90993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90994         return 0;
90995       }
90996       catch(std::invalid_argument &_e) {
90997         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90998         return 0;
90999       }
91000
91001     } catch (std::out_of_range& e) {
91002       {
91003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91004       };
91005     } catch (std::exception& e) {
91006       {
91007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91008       };
91009     } catch (Dali::DaliException e) {
91010       {
91011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91012       };
91013     } catch (...) {
91014       {
91015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91016       };
91017     }
91018   }
91019
91020   jresult = (void *)result;
91021   return jresult;
91022 }
91023
91024
91025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
91026   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91027   int arg2 ;
91028   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
91029
91030   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91031   arg2 = (int)jarg2;
91032   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
91033   if (!arg3) {
91034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
91035     return ;
91036   }
91037   {
91038     try {
91039       try {
91040         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);
91041       }
91042       catch(std::out_of_range &_e) {
91043         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91044         return ;
91045       }
91046
91047     } catch (std::out_of_range& e) {
91048       {
91049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91050       };
91051     } catch (std::exception& e) {
91052       {
91053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91054       };
91055     } catch (Dali::DaliException e) {
91056       {
91057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91058       };
91059     } catch (...) {
91060       {
91061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91062       };
91063     }
91064   }
91065
91066 }
91067
91068
91069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91070   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91071   int arg2 ;
91072   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
91073
91074   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91075   arg2 = (int)jarg2;
91076   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
91077   if (!arg3) {
91078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
91079     return ;
91080   }
91081   {
91082     try {
91083       try {
91084         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);
91085       }
91086       catch(std::out_of_range &_e) {
91087         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91088         return ;
91089       }
91090
91091     } catch (std::out_of_range& e) {
91092       {
91093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91094       };
91095     } catch (std::exception& e) {
91096       {
91097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91098       };
91099     } catch (Dali::DaliException e) {
91100       {
91101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91102       };
91103     } catch (...) {
91104       {
91105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91106       };
91107     }
91108   }
91109
91110 }
91111
91112
91113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
91114   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91115   int arg2 ;
91116
91117   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91118   arg2 = (int)jarg2;
91119   {
91120     try {
91121       try {
91122         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
91123       }
91124       catch(std::out_of_range &_e) {
91125         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91126         return ;
91127       }
91128
91129     } catch (std::out_of_range& e) {
91130       {
91131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91132       };
91133     } catch (std::exception& e) {
91134       {
91135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91136       };
91137     } catch (Dali::DaliException e) {
91138       {
91139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91140       };
91141     } catch (...) {
91142       {
91143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91144       };
91145     }
91146   }
91147
91148 }
91149
91150
91151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91152   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91153   int arg2 ;
91154   int arg3 ;
91155
91156   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91157   arg2 = (int)jarg2;
91158   arg3 = (int)jarg3;
91159   {
91160     try {
91161       try {
91162         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
91163       }
91164       catch(std::out_of_range &_e) {
91165         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91166         return ;
91167       }
91168       catch(std::invalid_argument &_e) {
91169         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91170         return ;
91171       }
91172
91173     } catch (std::out_of_range& e) {
91174       {
91175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91176       };
91177     } catch (std::exception& e) {
91178       {
91179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91180       };
91181     } catch (Dali::DaliException e) {
91182       {
91183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91184       };
91185     } catch (...) {
91186       {
91187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91188       };
91189     }
91190   }
91191
91192 }
91193
91194
91195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
91196   void * jresult ;
91197   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
91198   int arg2 ;
91199   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
91200
91201   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
91202   if (!arg1) {
91203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
91204     return 0;
91205   }
91206   arg2 = (int)jarg2;
91207   {
91208     try {
91209       try {
91210         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);
91211       }
91212       catch(std::out_of_range &_e) {
91213         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91214         return 0;
91215       }
91216
91217     } catch (std::out_of_range& e) {
91218       {
91219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91220       };
91221     } catch (std::exception& e) {
91222       {
91223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91224       };
91225     } catch (Dali::DaliException e) {
91226       {
91227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91228       };
91229     } catch (...) {
91230       {
91231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91232       };
91233     }
91234   }
91235
91236   jresult = (void *)result;
91237   return jresult;
91238 }
91239
91240
91241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
91242   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91243
91244   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91245   {
91246     try {
91247       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
91248     } catch (std::out_of_range& e) {
91249       {
91250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91251       };
91252     } catch (std::exception& e) {
91253       {
91254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91255       };
91256     } catch (Dali::DaliException e) {
91257       {
91258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91259       };
91260     } catch (...) {
91261       {
91262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91263       };
91264     }
91265   }
91266
91267 }
91268
91269
91270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
91271   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91272   int arg2 ;
91273   int arg3 ;
91274
91275   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91276   arg2 = (int)jarg2;
91277   arg3 = (int)jarg3;
91278   {
91279     try {
91280       try {
91281         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
91282       }
91283       catch(std::out_of_range &_e) {
91284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91285         return ;
91286       }
91287       catch(std::invalid_argument &_e) {
91288         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91289         return ;
91290       }
91291
91292     } catch (std::out_of_range& e) {
91293       {
91294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91295       };
91296     } catch (std::exception& e) {
91297       {
91298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91299       };
91300     } catch (Dali::DaliException e) {
91301       {
91302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91303       };
91304     } catch (...) {
91305       {
91306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91307       };
91308     }
91309   }
91310
91311 }
91312
91313
91314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
91315   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91316   int arg2 ;
91317   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
91318
91319   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91320   arg2 = (int)jarg2;
91321   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
91322   if (!arg3) {
91323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
91324     return ;
91325   }
91326   {
91327     try {
91328       try {
91329         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);
91330       }
91331       catch(std::out_of_range &_e) {
91332         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91333         return ;
91334       }
91335
91336     } catch (std::out_of_range& e) {
91337       {
91338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91339       };
91340     } catch (std::exception& e) {
91341       {
91342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91343       };
91344     } catch (Dali::DaliException e) {
91345       {
91346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91347       };
91348     } catch (...) {
91349       {
91350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91351       };
91352     }
91353   }
91354
91355 }
91356
91357
91358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
91359   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91360
91361   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91362   {
91363     try {
91364       delete arg1;
91365     } catch (std::out_of_range& e) {
91366       {
91367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91368       };
91369     } catch (std::exception& e) {
91370       {
91371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91372       };
91373     } catch (Dali::DaliException e) {
91374       {
91375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91376       };
91377     } catch (...) {
91378       {
91379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91380       };
91381     }
91382   }
91383
91384 }
91385
91386
91387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
91388   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91389
91390   arg1 = (std::vector< Dali::Actor > *)jarg1;
91391   {
91392     try {
91393       (arg1)->clear();
91394     } catch (std::out_of_range& e) {
91395       {
91396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91397       };
91398     } catch (std::exception& e) {
91399       {
91400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91401       };
91402     } catch (Dali::DaliException e) {
91403       {
91404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91405       };
91406     } catch (...) {
91407       {
91408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91409       };
91410     }
91411   }
91412
91413 }
91414
91415
91416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
91417   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91418   Dali::Actor *arg2 = 0 ;
91419
91420   arg1 = (std::vector< Dali::Actor > *)jarg1;
91421   arg2 = (Dali::Actor *)jarg2;
91422   if (!arg2) {
91423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
91424     return ;
91425   }
91426   {
91427     try {
91428       (arg1)->push_back((Dali::Actor const &)*arg2);
91429     } catch (std::out_of_range& e) {
91430       {
91431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91432       };
91433     } catch (std::exception& e) {
91434       {
91435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91436       };
91437     } catch (Dali::DaliException e) {
91438       {
91439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91440       };
91441     } catch (...) {
91442       {
91443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91444       };
91445     }
91446   }
91447
91448 }
91449
91450
91451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
91452   unsigned long jresult ;
91453   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91454   std::vector< Dali::Actor >::size_type result;
91455
91456   arg1 = (std::vector< Dali::Actor > *)jarg1;
91457   {
91458     try {
91459       result = ((std::vector< Dali::Actor > const *)arg1)->size();
91460     } catch (std::out_of_range& e) {
91461       {
91462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91463       };
91464     } catch (std::exception& e) {
91465       {
91466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91467       };
91468     } catch (Dali::DaliException e) {
91469       {
91470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91471       };
91472     } catch (...) {
91473       {
91474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91475       };
91476     }
91477   }
91478
91479   jresult = (unsigned long)result;
91480   return jresult;
91481 }
91482
91483
91484 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
91485   unsigned long jresult ;
91486   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91487   std::vector< Dali::Actor >::size_type result;
91488
91489   arg1 = (std::vector< Dali::Actor > *)jarg1;
91490   {
91491     try {
91492       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
91493     } catch (std::out_of_range& e) {
91494       {
91495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91496       };
91497     } catch (std::exception& e) {
91498       {
91499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91500       };
91501     } catch (Dali::DaliException e) {
91502       {
91503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91504       };
91505     } catch (...) {
91506       {
91507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91508       };
91509     }
91510   }
91511
91512   jresult = (unsigned long)result;
91513   return jresult;
91514 }
91515
91516
91517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
91518   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91519   std::vector< Dali::Actor >::size_type arg2 ;
91520
91521   arg1 = (std::vector< Dali::Actor > *)jarg1;
91522   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
91523   {
91524     try {
91525       (arg1)->reserve(arg2);
91526     } catch (std::out_of_range& e) {
91527       {
91528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91529       };
91530     } catch (std::exception& e) {
91531       {
91532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91533       };
91534     } catch (Dali::DaliException e) {
91535       {
91536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91537       };
91538     } catch (...) {
91539       {
91540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91541       };
91542     }
91543   }
91544
91545 }
91546
91547
91548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
91549   void * jresult ;
91550   std::vector< Dali::Actor > *result = 0 ;
91551
91552   {
91553     try {
91554       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
91555     } catch (std::out_of_range& e) {
91556       {
91557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91558       };
91559     } catch (std::exception& e) {
91560       {
91561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91562       };
91563     } catch (Dali::DaliException e) {
91564       {
91565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91566       };
91567     } catch (...) {
91568       {
91569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91570       };
91571     }
91572   }
91573
91574   jresult = (void *)result;
91575   return jresult;
91576 }
91577
91578
91579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
91580   void * jresult ;
91581   std::vector< Dali::Actor > *arg1 = 0 ;
91582   std::vector< Dali::Actor > *result = 0 ;
91583
91584   arg1 = (std::vector< Dali::Actor > *)jarg1;
91585   if (!arg1) {
91586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
91587     return 0;
91588   }
91589   {
91590     try {
91591       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
91592     } catch (std::out_of_range& e) {
91593       {
91594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91595       };
91596     } catch (std::exception& e) {
91597       {
91598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91599       };
91600     } catch (Dali::DaliException e) {
91601       {
91602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91603       };
91604     } catch (...) {
91605       {
91606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91607       };
91608     }
91609   }
91610
91611   jresult = (void *)result;
91612   return jresult;
91613 }
91614
91615
91616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
91617   void * jresult ;
91618   int arg1 ;
91619   std::vector< Dali::Actor > *result = 0 ;
91620
91621   arg1 = (int)jarg1;
91622   {
91623     try {
91624       try {
91625         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
91626       }
91627       catch(std::out_of_range &_e) {
91628         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91629         return 0;
91630       }
91631
91632     } catch (std::out_of_range& e) {
91633       {
91634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91635       };
91636     } catch (std::exception& e) {
91637       {
91638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91639       };
91640     } catch (Dali::DaliException e) {
91641       {
91642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91643       };
91644     } catch (...) {
91645       {
91646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91647       };
91648     }
91649   }
91650
91651   jresult = (void *)result;
91652   return jresult;
91653 }
91654
91655
91656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
91657   void * jresult ;
91658   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91659   int arg2 ;
91660   Dali::Actor result;
91661
91662   arg1 = (std::vector< Dali::Actor > *)jarg1;
91663   arg2 = (int)jarg2;
91664   {
91665     try {
91666       try {
91667         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
91668       }
91669       catch(std::out_of_range &_e) {
91670         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91671         return 0;
91672       }
91673
91674     } catch (std::out_of_range& e) {
91675       {
91676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91677       };
91678     } catch (std::exception& e) {
91679       {
91680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91681       };
91682     } catch (Dali::DaliException e) {
91683       {
91684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91685       };
91686     } catch (...) {
91687       {
91688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91689       };
91690     }
91691   }
91692
91693   jresult = new Dali::Actor((const Dali::Actor &)result);
91694   return jresult;
91695 }
91696
91697
91698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
91699   void * jresult ;
91700   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91701   int arg2 ;
91702   Dali::Actor *result = 0 ;
91703
91704   arg1 = (std::vector< Dali::Actor > *)jarg1;
91705   arg2 = (int)jarg2;
91706   {
91707     try {
91708       try {
91709         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
91710       }
91711       catch(std::out_of_range &_e) {
91712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91713         return 0;
91714       }
91715
91716     } catch (std::out_of_range& e) {
91717       {
91718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91719       };
91720     } catch (std::exception& e) {
91721       {
91722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91723       };
91724     } catch (Dali::DaliException e) {
91725       {
91726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91727       };
91728     } catch (...) {
91729       {
91730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91731       };
91732     }
91733   }
91734
91735   jresult = (void *)result;
91736   return jresult;
91737 }
91738
91739
91740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
91741   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91742   int arg2 ;
91743   Dali::Actor *arg3 = 0 ;
91744
91745   arg1 = (std::vector< Dali::Actor > *)jarg1;
91746   arg2 = (int)jarg2;
91747   arg3 = (Dali::Actor *)jarg3;
91748   if (!arg3) {
91749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
91750     return ;
91751   }
91752   {
91753     try {
91754       try {
91755         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
91756       }
91757       catch(std::out_of_range &_e) {
91758         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91759         return ;
91760       }
91761
91762     } catch (std::out_of_range& e) {
91763       {
91764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91765       };
91766     } catch (std::exception& e) {
91767       {
91768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91769       };
91770     } catch (Dali::DaliException e) {
91771       {
91772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91773       };
91774     } catch (...) {
91775       {
91776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91777       };
91778     }
91779   }
91780
91781 }
91782
91783
91784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
91785   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91786   std::vector< Dali::Actor > *arg2 = 0 ;
91787
91788   arg1 = (std::vector< Dali::Actor > *)jarg1;
91789   arg2 = (std::vector< Dali::Actor > *)jarg2;
91790   if (!arg2) {
91791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
91792     return ;
91793   }
91794   {
91795     try {
91796       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
91797     } catch (std::out_of_range& e) {
91798       {
91799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91800       };
91801     } catch (std::exception& e) {
91802       {
91803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91804       };
91805     } catch (Dali::DaliException e) {
91806       {
91807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91808       };
91809     } catch (...) {
91810       {
91811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91812       };
91813     }
91814   }
91815
91816 }
91817
91818
91819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91820   void * jresult ;
91821   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91822   int arg2 ;
91823   int arg3 ;
91824   std::vector< Dali::Actor > *result = 0 ;
91825
91826   arg1 = (std::vector< Dali::Actor > *)jarg1;
91827   arg2 = (int)jarg2;
91828   arg3 = (int)jarg3;
91829   {
91830     try {
91831       try {
91832         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
91833       }
91834       catch(std::out_of_range &_e) {
91835         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91836         return 0;
91837       }
91838       catch(std::invalid_argument &_e) {
91839         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91840         return 0;
91841       }
91842
91843     } catch (std::out_of_range& e) {
91844       {
91845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91846       };
91847     } catch (std::exception& e) {
91848       {
91849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91850       };
91851     } catch (Dali::DaliException e) {
91852       {
91853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91854       };
91855     } catch (...) {
91856       {
91857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91858       };
91859     }
91860   }
91861
91862   jresult = (void *)result;
91863   return jresult;
91864 }
91865
91866
91867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
91868   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91869   int arg2 ;
91870   Dali::Actor *arg3 = 0 ;
91871
91872   arg1 = (std::vector< Dali::Actor > *)jarg1;
91873   arg2 = (int)jarg2;
91874   arg3 = (Dali::Actor *)jarg3;
91875   if (!arg3) {
91876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
91877     return ;
91878   }
91879   {
91880     try {
91881       try {
91882         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
91883       }
91884       catch(std::out_of_range &_e) {
91885         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91886         return ;
91887       }
91888
91889     } catch (std::out_of_range& e) {
91890       {
91891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91892       };
91893     } catch (std::exception& e) {
91894       {
91895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91896       };
91897     } catch (Dali::DaliException e) {
91898       {
91899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91900       };
91901     } catch (...) {
91902       {
91903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91904       };
91905     }
91906   }
91907
91908 }
91909
91910
91911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91912   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91913   int arg2 ;
91914   std::vector< Dali::Actor > *arg3 = 0 ;
91915
91916   arg1 = (std::vector< Dali::Actor > *)jarg1;
91917   arg2 = (int)jarg2;
91918   arg3 = (std::vector< Dali::Actor > *)jarg3;
91919   if (!arg3) {
91920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
91921     return ;
91922   }
91923   {
91924     try {
91925       try {
91926         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
91927       }
91928       catch(std::out_of_range &_e) {
91929         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91930         return ;
91931       }
91932
91933     } catch (std::out_of_range& e) {
91934       {
91935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91936       };
91937     } catch (std::exception& e) {
91938       {
91939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91940       };
91941     } catch (Dali::DaliException e) {
91942       {
91943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91944       };
91945     } catch (...) {
91946       {
91947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91948       };
91949     }
91950   }
91951
91952 }
91953
91954
91955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
91956   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91957   int arg2 ;
91958
91959   arg1 = (std::vector< Dali::Actor > *)jarg1;
91960   arg2 = (int)jarg2;
91961   {
91962     try {
91963       try {
91964         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
91965       }
91966       catch(std::out_of_range &_e) {
91967         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91968         return ;
91969       }
91970
91971     } catch (std::out_of_range& e) {
91972       {
91973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91974       };
91975     } catch (std::exception& e) {
91976       {
91977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91978       };
91979     } catch (Dali::DaliException e) {
91980       {
91981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91982       };
91983     } catch (...) {
91984       {
91985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91986       };
91987     }
91988   }
91989
91990 }
91991
91992
91993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91994   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
91995   int arg2 ;
91996   int arg3 ;
91997
91998   arg1 = (std::vector< Dali::Actor > *)jarg1;
91999   arg2 = (int)jarg2;
92000   arg3 = (int)jarg3;
92001   {
92002     try {
92003       try {
92004         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
92005       }
92006       catch(std::out_of_range &_e) {
92007         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92008         return ;
92009       }
92010       catch(std::invalid_argument &_e) {
92011         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92012         return ;
92013       }
92014
92015     } catch (std::out_of_range& e) {
92016       {
92017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92018       };
92019     } catch (std::exception& e) {
92020       {
92021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92022       };
92023     } catch (Dali::DaliException e) {
92024       {
92025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92026       };
92027     } catch (...) {
92028       {
92029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92030       };
92031     }
92032   }
92033
92034 }
92035
92036
92037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
92038   void * jresult ;
92039   Dali::Actor *arg1 = 0 ;
92040   int arg2 ;
92041   std::vector< Dali::Actor > *result = 0 ;
92042
92043   arg1 = (Dali::Actor *)jarg1;
92044   if (!arg1) {
92045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
92046     return 0;
92047   }
92048   arg2 = (int)jarg2;
92049   {
92050     try {
92051       try {
92052         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
92053       }
92054       catch(std::out_of_range &_e) {
92055         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92056         return 0;
92057       }
92058
92059     } catch (std::out_of_range& e) {
92060       {
92061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92062       };
92063     } catch (std::exception& e) {
92064       {
92065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92066       };
92067     } catch (Dali::DaliException e) {
92068       {
92069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92070       };
92071     } catch (...) {
92072       {
92073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92074       };
92075     }
92076   }
92077
92078   jresult = (void *)result;
92079   return jresult;
92080 }
92081
92082
92083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
92084   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92085
92086   arg1 = (std::vector< Dali::Actor > *)jarg1;
92087   {
92088     try {
92089       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
92090     } catch (std::out_of_range& e) {
92091       {
92092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92093       };
92094     } catch (std::exception& e) {
92095       {
92096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92097       };
92098     } catch (Dali::DaliException e) {
92099       {
92100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92101       };
92102     } catch (...) {
92103       {
92104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92105       };
92106     }
92107   }
92108
92109 }
92110
92111
92112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92113   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92114   int arg2 ;
92115   int arg3 ;
92116
92117   arg1 = (std::vector< Dali::Actor > *)jarg1;
92118   arg2 = (int)jarg2;
92119   arg3 = (int)jarg3;
92120   {
92121     try {
92122       try {
92123         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92124       }
92125       catch(std::out_of_range &_e) {
92126         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92127         return ;
92128       }
92129       catch(std::invalid_argument &_e) {
92130         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92131         return ;
92132       }
92133
92134     } catch (std::out_of_range& e) {
92135       {
92136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92137       };
92138     } catch (std::exception& e) {
92139       {
92140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92141       };
92142     } catch (Dali::DaliException e) {
92143       {
92144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92145       };
92146     } catch (...) {
92147       {
92148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92149       };
92150     }
92151   }
92152
92153 }
92154
92155
92156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92157   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92158   int arg2 ;
92159   std::vector< Dali::Actor > *arg3 = 0 ;
92160
92161   arg1 = (std::vector< Dali::Actor > *)jarg1;
92162   arg2 = (int)jarg2;
92163   arg3 = (std::vector< Dali::Actor > *)jarg3;
92164   if (!arg3) {
92165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
92166     return ;
92167   }
92168   {
92169     try {
92170       try {
92171         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
92172       }
92173       catch(std::out_of_range &_e) {
92174         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92175         return ;
92176       }
92177
92178     } catch (std::out_of_range& e) {
92179       {
92180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92181       };
92182     } catch (std::exception& e) {
92183       {
92184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92185       };
92186     } catch (Dali::DaliException e) {
92187       {
92188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92189       };
92190     } catch (...) {
92191       {
92192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92193       };
92194     }
92195   }
92196
92197 }
92198
92199
92200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
92201   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92202
92203   arg1 = (std::vector< Dali::Actor > *)jarg1;
92204   {
92205     try {
92206       delete arg1;
92207     } catch (std::out_of_range& e) {
92208       {
92209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92210       };
92211     } catch (std::exception& e) {
92212       {
92213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92214       };
92215     } catch (Dali::DaliException e) {
92216       {
92217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92218       };
92219     } catch (...) {
92220       {
92221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92222       };
92223     }
92224   }
92225
92226 }
92227
92228
92229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
92230   unsigned int jresult ;
92231   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
92232   bool result;
92233
92234   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
92235   {
92236     try {
92237       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
92238     } catch (std::out_of_range& e) {
92239       {
92240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92241       };
92242     } catch (std::exception& e) {
92243       {
92244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92245       };
92246     } catch (Dali::DaliException e) {
92247       {
92248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92249       };
92250     } catch (...) {
92251       {
92252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92253       };
92254     }
92255   }
92256
92257   jresult = result;
92258   return jresult;
92259 }
92260
92261
92262 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
92263   unsigned long jresult ;
92264   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
92265   std::size_t result;
92266
92267   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
92268   {
92269     try {
92270       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
92271     } catch (std::out_of_range& e) {
92272       {
92273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92274       };
92275     } catch (std::exception& e) {
92276       {
92277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92278       };
92279     } catch (Dali::DaliException e) {
92280       {
92281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92282       };
92283     } catch (...) {
92284       {
92285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92286       };
92287     }
92288   }
92289
92290   jresult = (unsigned long)result;
92291   return jresult;
92292 }
92293
92294
92295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
92296   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
92297   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
92298
92299   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
92300   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
92301   {
92302     try {
92303       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
92304     } catch (std::out_of_range& e) {
92305       {
92306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92307       };
92308     } catch (std::exception& e) {
92309       {
92310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92311       };
92312     } catch (Dali::DaliException e) {
92313       {
92314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92315       };
92316     } catch (...) {
92317       {
92318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92319       };
92320     }
92321   }
92322
92323 }
92324
92325
92326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
92327   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
92328   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
92329
92330   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
92331   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
92332   {
92333     try {
92334       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
92335     } catch (std::out_of_range& e) {
92336       {
92337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92338       };
92339     } catch (std::exception& e) {
92340       {
92341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92342       };
92343     } catch (Dali::DaliException e) {
92344       {
92345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92346       };
92347     } catch (...) {
92348       {
92349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92350       };
92351     }
92352   }
92353
92354 }
92355
92356
92357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
92358   unsigned int jresult ;
92359   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
92360   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
92361   bool result;
92362
92363   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
92364   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
92365   if (!arg2) {
92366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
92367     return 0;
92368   }
92369   {
92370     try {
92371       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
92372     } catch (std::out_of_range& e) {
92373       {
92374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92375       };
92376     } catch (std::exception& e) {
92377       {
92378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92379       };
92380     } catch (Dali::DaliException e) {
92381       {
92382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92383       };
92384     } catch (...) {
92385       {
92386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92387       };
92388     }
92389   }
92390
92391   jresult = result;
92392   return jresult;
92393 }
92394
92395
92396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
92397   void * jresult ;
92398   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
92399
92400   {
92401     try {
92402       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
92403     } catch (std::out_of_range& e) {
92404       {
92405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92406       };
92407     } catch (std::exception& e) {
92408       {
92409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92410       };
92411     } catch (Dali::DaliException e) {
92412       {
92413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92414       };
92415     } catch (...) {
92416       {
92417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92418       };
92419     }
92420   }
92421
92422   jresult = (void *)result;
92423   return jresult;
92424 }
92425
92426
92427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
92428   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
92429
92430   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
92431   {
92432     try {
92433       delete arg1;
92434     } catch (std::out_of_range& e) {
92435       {
92436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92437       };
92438     } catch (std::exception& e) {
92439       {
92440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92441       };
92442     } catch (Dali::DaliException e) {
92443       {
92444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92445       };
92446     } catch (...) {
92447       {
92448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92449       };
92450     }
92451   }
92452
92453 }
92454
92455
92456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
92457   unsigned int jresult ;
92458   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
92459   bool result;
92460
92461   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
92462   {
92463     try {
92464       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);
92465     } catch (std::out_of_range& e) {
92466       {
92467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92468       };
92469     } catch (std::exception& e) {
92470       {
92471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92472       };
92473     } catch (Dali::DaliException e) {
92474       {
92475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92476       };
92477     } catch (...) {
92478       {
92479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92480       };
92481     }
92482   }
92483
92484   jresult = result;
92485   return jresult;
92486 }
92487
92488
92489 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
92490   unsigned long jresult ;
92491   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
92492   std::size_t result;
92493
92494   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
92495   {
92496     try {
92497       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);
92498     } catch (std::out_of_range& e) {
92499       {
92500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92501       };
92502     } catch (std::exception& e) {
92503       {
92504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92505       };
92506     } catch (Dali::DaliException e) {
92507       {
92508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92509       };
92510     } catch (...) {
92511       {
92512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92513       };
92514     }
92515   }
92516
92517   jresult = (unsigned long)result;
92518   return jresult;
92519 }
92520
92521
92522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
92523   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
92524   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
92525
92526   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
92527   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
92528   {
92529     try {
92530       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
92531     } catch (std::out_of_range& e) {
92532       {
92533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92534       };
92535     } catch (std::exception& e) {
92536       {
92537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92538       };
92539     } catch (Dali::DaliException e) {
92540       {
92541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92542       };
92543     } catch (...) {
92544       {
92545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92546       };
92547     }
92548   }
92549
92550 }
92551
92552
92553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
92554   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
92555   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
92556
92557   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
92558   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
92559   {
92560     try {
92561       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
92562     } catch (std::out_of_range& e) {
92563       {
92564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92565       };
92566     } catch (std::exception& e) {
92567       {
92568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92569       };
92570     } catch (Dali::DaliException e) {
92571       {
92572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92573       };
92574     } catch (...) {
92575       {
92576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92577       };
92578     }
92579   }
92580
92581 }
92582
92583
92584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
92585   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
92586   Dali::Actor arg2 ;
92587   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
92588   Dali::Actor *argp2 ;
92589
92590   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
92591   argp2 = (Dali::Actor *)jarg2;
92592   if (!argp2) {
92593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92594     return ;
92595   }
92596   arg2 = *argp2;
92597   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
92598   {
92599     try {
92600       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
92601     } catch (std::out_of_range& e) {
92602       {
92603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92604       };
92605     } catch (std::exception& e) {
92606       {
92607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92608       };
92609     } catch (Dali::DaliException e) {
92610       {
92611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92612       };
92613     } catch (...) {
92614       {
92615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92616       };
92617     }
92618   }
92619
92620 }
92621
92622
92623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
92624   void * jresult ;
92625   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
92626
92627   {
92628     try {
92629       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
92630     } catch (std::out_of_range& e) {
92631       {
92632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92633       };
92634     } catch (std::exception& e) {
92635       {
92636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92637       };
92638     } catch (Dali::DaliException e) {
92639       {
92640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92641       };
92642     } catch (...) {
92643       {
92644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92645       };
92646     }
92647   }
92648
92649   jresult = (void *)result;
92650   return jresult;
92651 }
92652
92653
92654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
92655   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
92656
92657   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
92658   {
92659     try {
92660       delete arg1;
92661     } catch (std::out_of_range& e) {
92662       {
92663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92664       };
92665     } catch (std::exception& e) {
92666       {
92667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92668       };
92669     } catch (Dali::DaliException e) {
92670       {
92671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92672       };
92673     } catch (...) {
92674       {
92675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92676       };
92677     }
92678   }
92679
92680 }
92681
92682
92683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
92684   unsigned int jresult ;
92685   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
92686   bool result;
92687
92688   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
92689   {
92690     try {
92691       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
92692     } catch (std::out_of_range& e) {
92693       {
92694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92695       };
92696     } catch (std::exception& e) {
92697       {
92698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92699       };
92700     } catch (Dali::DaliException e) {
92701       {
92702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92703       };
92704     } catch (...) {
92705       {
92706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92707       };
92708     }
92709   }
92710
92711   jresult = result;
92712   return jresult;
92713 }
92714
92715
92716 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
92717   unsigned long jresult ;
92718   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
92719   std::size_t result;
92720
92721   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
92722   {
92723     try {
92724       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
92725     } catch (std::out_of_range& e) {
92726       {
92727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92728       };
92729     } catch (std::exception& e) {
92730       {
92731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92732       };
92733     } catch (Dali::DaliException e) {
92734       {
92735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92736       };
92737     } catch (...) {
92738       {
92739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92740       };
92741     }
92742   }
92743
92744   jresult = (unsigned long)result;
92745   return jresult;
92746 }
92747
92748
92749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
92750   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
92751   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
92752
92753   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
92754   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
92755   {
92756     try {
92757       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
92758     } catch (std::out_of_range& e) {
92759       {
92760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92761       };
92762     } catch (std::exception& e) {
92763       {
92764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92765       };
92766     } catch (Dali::DaliException e) {
92767       {
92768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92769       };
92770     } catch (...) {
92771       {
92772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92773       };
92774     }
92775   }
92776
92777 }
92778
92779
92780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92781   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
92782   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
92783
92784   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
92785   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
92786   {
92787     try {
92788       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
92789     } catch (std::out_of_range& e) {
92790       {
92791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92792       };
92793     } catch (std::exception& e) {
92794       {
92795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92796       };
92797     } catch (Dali::DaliException e) {
92798       {
92799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92800       };
92801     } catch (...) {
92802       {
92803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92804       };
92805     }
92806   }
92807
92808 }
92809
92810
92811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92812   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
92813   Dali::Actor arg2 ;
92814   Dali::Actor arg3 ;
92815   Dali::Actor *argp2 ;
92816   Dali::Actor *argp3 ;
92817
92818   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
92819   argp2 = (Dali::Actor *)jarg2;
92820   if (!argp2) {
92821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92822     return ;
92823   }
92824   arg2 = *argp2;
92825   argp3 = (Dali::Actor *)jarg3;
92826   if (!argp3) {
92827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92828     return ;
92829   }
92830   arg3 = *argp3;
92831   {
92832     try {
92833       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
92834     } catch (std::out_of_range& e) {
92835       {
92836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92837       };
92838     } catch (std::exception& e) {
92839       {
92840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92841       };
92842     } catch (Dali::DaliException e) {
92843       {
92844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92845       };
92846     } catch (...) {
92847       {
92848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92849       };
92850     }
92851   }
92852
92853 }
92854
92855
92856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
92857   void * jresult ;
92858   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
92859
92860   {
92861     try {
92862       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
92863     } catch (std::out_of_range& e) {
92864       {
92865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92866       };
92867     } catch (std::exception& e) {
92868       {
92869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92870       };
92871     } catch (Dali::DaliException e) {
92872       {
92873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92874       };
92875     } catch (...) {
92876       {
92877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92878       };
92879     }
92880   }
92881
92882   jresult = (void *)result;
92883   return jresult;
92884 }
92885
92886
92887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
92888   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
92889
92890   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
92891   {
92892     try {
92893       delete arg1;
92894     } catch (std::out_of_range& e) {
92895       {
92896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92897       };
92898     } catch (std::exception& e) {
92899       {
92900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92901       };
92902     } catch (Dali::DaliException e) {
92903       {
92904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92905       };
92906     } catch (...) {
92907       {
92908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92909       };
92910     }
92911   }
92912
92913 }
92914
92915
92916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
92917   unsigned int jresult ;
92918   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
92919   bool result;
92920
92921   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
92922   {
92923     try {
92924       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
92925     } catch (std::out_of_range& e) {
92926       {
92927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92928       };
92929     } catch (std::exception& e) {
92930       {
92931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92932       };
92933     } catch (Dali::DaliException e) {
92934       {
92935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92936       };
92937     } catch (...) {
92938       {
92939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92940       };
92941     }
92942   }
92943
92944   jresult = result;
92945   return jresult;
92946 }
92947
92948
92949 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
92950   unsigned long jresult ;
92951   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
92952   std::size_t result;
92953
92954   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
92955   {
92956     try {
92957       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
92958     } catch (std::out_of_range& e) {
92959       {
92960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92961       };
92962     } catch (std::exception& e) {
92963       {
92964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92965       };
92966     } catch (Dali::DaliException e) {
92967       {
92968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92969       };
92970     } catch (...) {
92971       {
92972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92973       };
92974     }
92975   }
92976
92977   jresult = (unsigned long)result;
92978   return jresult;
92979 }
92980
92981
92982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
92983   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
92984   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
92985
92986   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
92987   arg2 = (void (*)(Dali::Actor,bool))jarg2;
92988   {
92989     try {
92990       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
92991     } catch (std::out_of_range& e) {
92992       {
92993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92994       };
92995     } catch (std::exception& e) {
92996       {
92997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92998       };
92999     } catch (Dali::DaliException e) {
93000       {
93001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93002       };
93003     } catch (...) {
93004       {
93005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93006       };
93007     }
93008   }
93009
93010 }
93011
93012
93013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93014   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
93015   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
93016
93017   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
93018   arg2 = (void (*)(Dali::Actor,bool))jarg2;
93019   {
93020     try {
93021       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
93022     } catch (std::out_of_range& e) {
93023       {
93024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93025       };
93026     } catch (std::exception& e) {
93027       {
93028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93029       };
93030     } catch (Dali::DaliException e) {
93031       {
93032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93033       };
93034     } catch (...) {
93035       {
93036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93037       };
93038     }
93039   }
93040
93041 }
93042
93043
93044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
93045   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
93046   Dali::Actor arg2 ;
93047   bool arg3 ;
93048   Dali::Actor *argp2 ;
93049
93050   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
93051   argp2 = (Dali::Actor *)jarg2;
93052   if (!argp2) {
93053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93054     return ;
93055   }
93056   arg2 = *argp2;
93057   arg3 = jarg3 ? true : false;
93058   {
93059     try {
93060       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
93061     } catch (std::out_of_range& e) {
93062       {
93063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93064       };
93065     } catch (std::exception& e) {
93066       {
93067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93068       };
93069     } catch (Dali::DaliException e) {
93070       {
93071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93072       };
93073     } catch (...) {
93074       {
93075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93076       };
93077     }
93078   }
93079
93080 }
93081
93082
93083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
93084   void * jresult ;
93085   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
93086
93087   {
93088     try {
93089       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
93090     } catch (std::out_of_range& e) {
93091       {
93092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93093       };
93094     } catch (std::exception& e) {
93095       {
93096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93097       };
93098     } catch (Dali::DaliException e) {
93099       {
93100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93101       };
93102     } catch (...) {
93103       {
93104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93105       };
93106     }
93107   }
93108
93109   jresult = (void *)result;
93110   return jresult;
93111 }
93112
93113
93114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
93115   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
93116
93117   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
93118   {
93119     try {
93120       delete arg1;
93121     } catch (std::out_of_range& e) {
93122       {
93123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93124       };
93125     } catch (std::exception& e) {
93126       {
93127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93128       };
93129     } catch (Dali::DaliException e) {
93130       {
93131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93132       };
93133     } catch (...) {
93134       {
93135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93136       };
93137     }
93138   }
93139
93140 }
93141
93142
93143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
93144   unsigned int jresult ;
93145   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93146   bool result;
93147
93148   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93149   {
93150     try {
93151       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);
93152     } catch (std::out_of_range& e) {
93153       {
93154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93155       };
93156     } catch (std::exception& e) {
93157       {
93158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93159       };
93160     } catch (Dali::DaliException e) {
93161       {
93162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93163       };
93164     } catch (...) {
93165       {
93166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93167       };
93168     }
93169   }
93170
93171   jresult = result;
93172   return jresult;
93173 }
93174
93175
93176 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
93177   unsigned long jresult ;
93178   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93179   std::size_t result;
93180
93181   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93182   {
93183     try {
93184       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);
93185     } catch (std::out_of_range& e) {
93186       {
93187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93188       };
93189     } catch (std::exception& e) {
93190       {
93191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93192       };
93193     } catch (Dali::DaliException e) {
93194       {
93195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93196       };
93197     } catch (...) {
93198       {
93199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93200       };
93201     }
93202   }
93203
93204   jresult = (unsigned long)result;
93205   return jresult;
93206 }
93207
93208
93209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
93210   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93211   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
93212
93213   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93214   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
93215   {
93216     try {
93217       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
93218     } catch (std::out_of_range& e) {
93219       {
93220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93221       };
93222     } catch (std::exception& e) {
93223       {
93224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93225       };
93226     } catch (Dali::DaliException e) {
93227       {
93228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93229       };
93230     } catch (...) {
93231       {
93232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93233       };
93234     }
93235   }
93236
93237 }
93238
93239
93240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93241   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93242   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
93243
93244   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93245   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
93246   {
93247     try {
93248       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
93249     } catch (std::out_of_range& e) {
93250       {
93251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93252       };
93253     } catch (std::exception& e) {
93254       {
93255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93256       };
93257     } catch (Dali::DaliException e) {
93258       {
93259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93260       };
93261     } catch (...) {
93262       {
93263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93264       };
93265     }
93266   }
93267
93268 }
93269
93270
93271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93272   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93273   Dali::Toolkit::StyleManager arg2 ;
93274   Dali::StyleChange::Type arg3 ;
93275   Dali::Toolkit::StyleManager *argp2 ;
93276
93277   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93278   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
93279   if (!argp2) {
93280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
93281     return ;
93282   }
93283   arg2 = *argp2;
93284   arg3 = (Dali::StyleChange::Type)jarg3;
93285   {
93286     try {
93287       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
93288     } catch (std::out_of_range& e) {
93289       {
93290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93291       };
93292     } catch (std::exception& e) {
93293       {
93294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93295       };
93296     } catch (Dali::DaliException e) {
93297       {
93298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93299       };
93300     } catch (...) {
93301       {
93302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93303       };
93304     }
93305   }
93306
93307 }
93308
93309
93310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
93311   void * jresult ;
93312   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
93313
93314   {
93315     try {
93316       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
93317     } catch (std::out_of_range& e) {
93318       {
93319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93320       };
93321     } catch (std::exception& e) {
93322       {
93323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93324       };
93325     } catch (Dali::DaliException e) {
93326       {
93327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93328       };
93329     } catch (...) {
93330       {
93331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93332       };
93333     }
93334   }
93335
93336   jresult = (void *)result;
93337   return jresult;
93338 }
93339
93340
93341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
93342   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93343
93344   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93345   {
93346     try {
93347       delete arg1;
93348     } catch (std::out_of_range& e) {
93349       {
93350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93351       };
93352     } catch (std::exception& e) {
93353       {
93354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93355       };
93356     } catch (Dali::DaliException e) {
93357       {
93358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93359       };
93360     } catch (...) {
93361       {
93362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93363       };
93364     }
93365   }
93366
93367 }
93368
93369
93370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
93371   unsigned int jresult ;
93372   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
93373   bool result;
93374
93375   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
93376   {
93377     try {
93378       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
93379     } catch (std::out_of_range& e) {
93380       {
93381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93382       };
93383     } catch (std::exception& e) {
93384       {
93385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93386       };
93387     } catch (Dali::DaliException e) {
93388       {
93389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93390       };
93391     } catch (...) {
93392       {
93393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93394       };
93395     }
93396   }
93397
93398   jresult = result;
93399   return jresult;
93400 }
93401
93402
93403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
93404   unsigned long jresult ;
93405   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
93406   std::size_t result;
93407
93408   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
93409   {
93410     try {
93411       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
93412     } catch (std::out_of_range& e) {
93413       {
93414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93415       };
93416     } catch (std::exception& e) {
93417       {
93418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93419       };
93420     } catch (Dali::DaliException e) {
93421       {
93422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93423       };
93424     } catch (...) {
93425       {
93426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93427       };
93428     }
93429   }
93430
93431   jresult = (unsigned long)result;
93432   return jresult;
93433 }
93434
93435
93436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
93437   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
93438   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
93439
93440   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
93441   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
93442   {
93443     try {
93444       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
93445     } catch (std::out_of_range& e) {
93446       {
93447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93448       };
93449     } catch (std::exception& e) {
93450       {
93451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93452       };
93453     } catch (Dali::DaliException e) {
93454       {
93455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93456       };
93457     } catch (...) {
93458       {
93459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93460       };
93461     }
93462   }
93463
93464 }
93465
93466
93467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
93468   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
93469   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
93470
93471   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
93472   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
93473   {
93474     try {
93475       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
93476     } catch (std::out_of_range& e) {
93477       {
93478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93479       };
93480     } catch (std::exception& e) {
93481       {
93482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93483       };
93484     } catch (Dali::DaliException e) {
93485       {
93486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93487       };
93488     } catch (...) {
93489       {
93490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93491       };
93492     }
93493   }
93494
93495 }
93496
93497
93498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
93499   unsigned int jresult ;
93500   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
93501   Dali::Toolkit::Button arg2 ;
93502   Dali::Toolkit::Button *argp2 ;
93503   bool result;
93504
93505   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
93506   argp2 = (Dali::Toolkit::Button *)jarg2;
93507   if (!argp2) {
93508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
93509     return 0;
93510   }
93511   arg2 = *argp2;
93512   {
93513     try {
93514       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
93515     } catch (std::out_of_range& e) {
93516       {
93517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93518       };
93519     } catch (std::exception& e) {
93520       {
93521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93522       };
93523     } catch (Dali::DaliException e) {
93524       {
93525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93526       };
93527     } catch (...) {
93528       {
93529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93530       };
93531     }
93532   }
93533
93534   jresult = result;
93535   return jresult;
93536 }
93537
93538
93539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
93540   void * jresult ;
93541   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
93542
93543   {
93544     try {
93545       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
93546     } catch (std::out_of_range& e) {
93547       {
93548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93549       };
93550     } catch (std::exception& e) {
93551       {
93552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93553       };
93554     } catch (Dali::DaliException e) {
93555       {
93556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93557       };
93558     } catch (...) {
93559       {
93560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93561       };
93562     }
93563   }
93564
93565   jresult = (void *)result;
93566   return jresult;
93567 }
93568
93569
93570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
93571   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
93572
93573   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
93574   {
93575     try {
93576       delete arg1;
93577     } catch (std::out_of_range& e) {
93578       {
93579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93580       };
93581     } catch (std::exception& e) {
93582       {
93583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93584       };
93585     } catch (Dali::DaliException e) {
93586       {
93587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93588       };
93589     } catch (...) {
93590       {
93591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93592       };
93593     }
93594   }
93595
93596 }
93597
93598
93599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
93600   unsigned int jresult ;
93601   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
93602   bool result;
93603
93604   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
93605   {
93606     try {
93607       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
93608     } catch (std::out_of_range& e) {
93609       {
93610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93611       };
93612     } catch (std::exception& e) {
93613       {
93614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93615       };
93616     } catch (Dali::DaliException e) {
93617       {
93618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93619       };
93620     } catch (...) {
93621       {
93622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93623       };
93624     }
93625   }
93626
93627   jresult = result;
93628   return jresult;
93629 }
93630
93631
93632 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
93633   unsigned long jresult ;
93634   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
93635   std::size_t result;
93636
93637   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
93638   {
93639     try {
93640       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
93641     } catch (std::out_of_range& e) {
93642       {
93643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93644       };
93645     } catch (std::exception& e) {
93646       {
93647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93648       };
93649     } catch (Dali::DaliException e) {
93650       {
93651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93652       };
93653     } catch (...) {
93654       {
93655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93656       };
93657     }
93658   }
93659
93660   jresult = (unsigned long)result;
93661   return jresult;
93662 }
93663
93664
93665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
93666   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
93667   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
93668
93669   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
93670   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
93671   {
93672     try {
93673       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
93674     } catch (std::out_of_range& e) {
93675       {
93676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93677       };
93678     } catch (std::exception& e) {
93679       {
93680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93681       };
93682     } catch (Dali::DaliException e) {
93683       {
93684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93685       };
93686     } catch (...) {
93687       {
93688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93689       };
93690     }
93691   }
93692
93693 }
93694
93695
93696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
93697   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
93698   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
93699
93700   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
93701   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
93702   {
93703     try {
93704       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
93705     } catch (std::out_of_range& e) {
93706       {
93707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93708       };
93709     } catch (std::exception& e) {
93710       {
93711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93712       };
93713     } catch (Dali::DaliException e) {
93714       {
93715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93716       };
93717     } catch (...) {
93718       {
93719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93720       };
93721     }
93722   }
93723
93724 }
93725
93726
93727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
93728   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
93729   Dali::Toolkit::GaussianBlurView arg2 ;
93730   Dali::Toolkit::GaussianBlurView *argp2 ;
93731
93732   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
93733   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
93734   if (!argp2) {
93735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
93736     return ;
93737   }
93738   arg2 = *argp2;
93739   {
93740     try {
93741       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
93742     } catch (std::out_of_range& e) {
93743       {
93744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93745       };
93746     } catch (std::exception& e) {
93747       {
93748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93749       };
93750     } catch (Dali::DaliException e) {
93751       {
93752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93753       };
93754     } catch (...) {
93755       {
93756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93757       };
93758     }
93759   }
93760
93761 }
93762
93763
93764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
93765   void * jresult ;
93766   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
93767
93768   {
93769     try {
93770       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
93771     } catch (std::out_of_range& e) {
93772       {
93773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93774       };
93775     } catch (std::exception& e) {
93776       {
93777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93778       };
93779     } catch (Dali::DaliException e) {
93780       {
93781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93782       };
93783     } catch (...) {
93784       {
93785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93786       };
93787     }
93788   }
93789
93790   jresult = (void *)result;
93791   return jresult;
93792 }
93793
93794
93795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
93796   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
93797
93798   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
93799   {
93800     try {
93801       delete arg1;
93802     } catch (std::out_of_range& e) {
93803       {
93804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93805       };
93806     } catch (std::exception& e) {
93807       {
93808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93809       };
93810     } catch (Dali::DaliException e) {
93811       {
93812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93813       };
93814     } catch (...) {
93815       {
93816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93817       };
93818     }
93819   }
93820
93821 }
93822
93823
93824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
93825   unsigned int jresult ;
93826   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93827   bool result;
93828
93829   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93830   {
93831     try {
93832       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);
93833     } catch (std::out_of_range& e) {
93834       {
93835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93836       };
93837     } catch (std::exception& e) {
93838       {
93839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93840       };
93841     } catch (Dali::DaliException e) {
93842       {
93843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93844       };
93845     } catch (...) {
93846       {
93847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93848       };
93849     }
93850   }
93851
93852   jresult = result;
93853   return jresult;
93854 }
93855
93856
93857 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
93858   unsigned long jresult ;
93859   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93860   std::size_t result;
93861
93862   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93863   {
93864     try {
93865       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);
93866     } catch (std::out_of_range& e) {
93867       {
93868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93869       };
93870     } catch (std::exception& e) {
93871       {
93872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93873       };
93874     } catch (Dali::DaliException e) {
93875       {
93876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93877       };
93878     } catch (...) {
93879       {
93880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93881       };
93882     }
93883   }
93884
93885   jresult = (unsigned long)result;
93886   return jresult;
93887 }
93888
93889
93890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
93891   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93892   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
93893
93894   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93895   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
93896   {
93897     try {
93898       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
93899     } catch (std::out_of_range& e) {
93900       {
93901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93902       };
93903     } catch (std::exception& e) {
93904       {
93905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93906       };
93907     } catch (Dali::DaliException e) {
93908       {
93909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93910       };
93911     } catch (...) {
93912       {
93913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93914       };
93915     }
93916   }
93917
93918 }
93919
93920
93921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
93922   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93923   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
93924
93925   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93926   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
93927   {
93928     try {
93929       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
93930     } catch (std::out_of_range& e) {
93931       {
93932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93933       };
93934     } catch (std::exception& e) {
93935       {
93936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93937       };
93938     } catch (Dali::DaliException e) {
93939       {
93940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93941       };
93942     } catch (...) {
93943       {
93944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93945       };
93946     }
93947   }
93948
93949 }
93950
93951
93952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
93953   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
93954   Dali::Toolkit::PageTurnView arg2 ;
93955   unsigned int arg3 ;
93956   bool arg4 ;
93957   Dali::Toolkit::PageTurnView *argp2 ;
93958
93959   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
93960   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
93961   if (!argp2) {
93962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
93963     return ;
93964   }
93965   arg2 = *argp2;
93966   arg3 = (unsigned int)jarg3;
93967   arg4 = jarg4 ? true : false;
93968   {
93969     try {
93970       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
93971     } catch (std::out_of_range& e) {
93972       {
93973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93974       };
93975     } catch (std::exception& e) {
93976       {
93977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93978       };
93979     } catch (Dali::DaliException e) {
93980       {
93981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93982       };
93983     } catch (...) {
93984       {
93985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93986       };
93987     }
93988   }
93989
93990 }
93991
93992
93993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
93994   void * jresult ;
93995   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
93996
93997   {
93998     try {
93999       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
94000     } catch (std::out_of_range& e) {
94001       {
94002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94003       };
94004     } catch (std::exception& e) {
94005       {
94006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94007       };
94008     } catch (Dali::DaliException e) {
94009       {
94010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94011       };
94012     } catch (...) {
94013       {
94014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94015       };
94016     }
94017   }
94018
94019   jresult = (void *)result;
94020   return jresult;
94021 }
94022
94023
94024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
94025   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
94026
94027   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
94028   {
94029     try {
94030       delete arg1;
94031     } catch (std::out_of_range& e) {
94032       {
94033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94034       };
94035     } catch (std::exception& e) {
94036       {
94037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94038       };
94039     } catch (Dali::DaliException e) {
94040       {
94041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94042       };
94043     } catch (...) {
94044       {
94045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94046       };
94047     }
94048   }
94049
94050 }
94051
94052
94053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
94054   unsigned int jresult ;
94055   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94056   bool result;
94057
94058   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94059   {
94060     try {
94061       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
94062     } catch (std::out_of_range& e) {
94063       {
94064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94065       };
94066     } catch (std::exception& e) {
94067       {
94068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94069       };
94070     } catch (Dali::DaliException e) {
94071       {
94072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94073       };
94074     } catch (...) {
94075       {
94076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94077       };
94078     }
94079   }
94080
94081   jresult = result;
94082   return jresult;
94083 }
94084
94085
94086 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
94087   unsigned long jresult ;
94088   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94089   std::size_t result;
94090
94091   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94092   {
94093     try {
94094       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
94095     } catch (std::out_of_range& e) {
94096       {
94097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94098       };
94099     } catch (std::exception& e) {
94100       {
94101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94102       };
94103     } catch (Dali::DaliException e) {
94104       {
94105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94106       };
94107     } catch (...) {
94108       {
94109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94110       };
94111     }
94112   }
94113
94114   jresult = (unsigned long)result;
94115   return jresult;
94116 }
94117
94118
94119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
94120   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94121   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
94122
94123   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94124   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
94125   {
94126     try {
94127       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
94128     } catch (std::out_of_range& e) {
94129       {
94130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94131       };
94132     } catch (std::exception& e) {
94133       {
94134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94135       };
94136     } catch (Dali::DaliException e) {
94137       {
94138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94139       };
94140     } catch (...) {
94141       {
94142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94143       };
94144     }
94145   }
94146
94147 }
94148
94149
94150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
94151   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94152   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
94153
94154   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94155   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
94156   {
94157     try {
94158       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
94159     } catch (std::out_of_range& e) {
94160       {
94161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94162       };
94163     } catch (std::exception& e) {
94164       {
94165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94166       };
94167     } catch (Dali::DaliException e) {
94168       {
94169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94170       };
94171     } catch (...) {
94172       {
94173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94174       };
94175     }
94176   }
94177
94178 }
94179
94180
94181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
94182   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94183   Dali::Toolkit::PageTurnView arg2 ;
94184   Dali::Toolkit::PageTurnView *argp2 ;
94185
94186   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94187   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
94188   if (!argp2) {
94189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
94190     return ;
94191   }
94192   arg2 = *argp2;
94193   {
94194     try {
94195       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
94196     } catch (std::out_of_range& e) {
94197       {
94198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94199       };
94200     } catch (std::exception& e) {
94201       {
94202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94203       };
94204     } catch (Dali::DaliException e) {
94205       {
94206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94207       };
94208     } catch (...) {
94209       {
94210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94211       };
94212     }
94213   }
94214
94215 }
94216
94217
94218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
94219   void * jresult ;
94220   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
94221
94222   {
94223     try {
94224       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
94225     } catch (std::out_of_range& e) {
94226       {
94227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94228       };
94229     } catch (std::exception& e) {
94230       {
94231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94232       };
94233     } catch (Dali::DaliException e) {
94234       {
94235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94236       };
94237     } catch (...) {
94238       {
94239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94240       };
94241     }
94242   }
94243
94244   jresult = (void *)result;
94245   return jresult;
94246 }
94247
94248
94249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
94250   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94251
94252   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94253   {
94254     try {
94255       delete arg1;
94256     } catch (std::out_of_range& e) {
94257       {
94258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94259       };
94260     } catch (std::exception& e) {
94261       {
94262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94263       };
94264     } catch (Dali::DaliException e) {
94265       {
94266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94267       };
94268     } catch (...) {
94269       {
94270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94271       };
94272     }
94273   }
94274
94275 }
94276
94277
94278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
94279   unsigned int jresult ;
94280   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
94281   bool result;
94282
94283   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
94284   {
94285     try {
94286       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);
94287     } catch (std::out_of_range& e) {
94288       {
94289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94290       };
94291     } catch (std::exception& e) {
94292       {
94293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94294       };
94295     } catch (Dali::DaliException e) {
94296       {
94297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94298       };
94299     } catch (...) {
94300       {
94301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94302       };
94303     }
94304   }
94305
94306   jresult = result;
94307   return jresult;
94308 }
94309
94310
94311 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
94312   unsigned long jresult ;
94313   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
94314   std::size_t result;
94315
94316   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
94317   {
94318     try {
94319       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);
94320     } catch (std::out_of_range& e) {
94321       {
94322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94323       };
94324     } catch (std::exception& e) {
94325       {
94326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94327       };
94328     } catch (Dali::DaliException e) {
94329       {
94330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94331       };
94332     } catch (...) {
94333       {
94334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94335       };
94336     }
94337   }
94338
94339   jresult = (unsigned long)result;
94340   return jresult;
94341 }
94342
94343
94344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
94345   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
94346   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
94347
94348   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
94349   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
94350   {
94351     try {
94352       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
94353     } catch (std::out_of_range& e) {
94354       {
94355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94356       };
94357     } catch (std::exception& e) {
94358       {
94359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94360       };
94361     } catch (Dali::DaliException e) {
94362       {
94363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94364       };
94365     } catch (...) {
94366       {
94367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94368       };
94369     }
94370   }
94371
94372 }
94373
94374
94375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94376   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
94377   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
94378
94379   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
94380   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
94381   {
94382     try {
94383       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
94384     } catch (std::out_of_range& e) {
94385       {
94386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94387       };
94388     } catch (std::exception& e) {
94389       {
94390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94391       };
94392     } catch (Dali::DaliException e) {
94393       {
94394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94395       };
94396     } catch (...) {
94397       {
94398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94399       };
94400     }
94401   }
94402
94403 }
94404
94405
94406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
94407   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
94408   Dali::Toolkit::ProgressBar arg2 ;
94409   float arg3 ;
94410   float arg4 ;
94411   Dali::Toolkit::ProgressBar *argp2 ;
94412
94413   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
94414   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
94415   if (!argp2) {
94416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
94417     return ;
94418   }
94419   arg2 = *argp2;
94420   arg3 = (float)jarg3;
94421   arg4 = (float)jarg4;
94422   {
94423     try {
94424       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
94425     } catch (std::out_of_range& e) {
94426       {
94427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94428       };
94429     } catch (std::exception& e) {
94430       {
94431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94432       };
94433     } catch (Dali::DaliException e) {
94434       {
94435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94436       };
94437     } catch (...) {
94438       {
94439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94440       };
94441     }
94442   }
94443
94444 }
94445
94446
94447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
94448   void * jresult ;
94449   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
94450
94451   {
94452     try {
94453       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
94454     } catch (std::out_of_range& e) {
94455       {
94456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94457       };
94458     } catch (std::exception& e) {
94459       {
94460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94461       };
94462     } catch (Dali::DaliException e) {
94463       {
94464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94465       };
94466     } catch (...) {
94467       {
94468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94469       };
94470     }
94471   }
94472
94473   jresult = (void *)result;
94474   return jresult;
94475 }
94476
94477
94478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
94479   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
94480
94481   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
94482   {
94483     try {
94484       delete arg1;
94485     } catch (std::out_of_range& e) {
94486       {
94487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94488       };
94489     } catch (std::exception& e) {
94490       {
94491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94492       };
94493     } catch (Dali::DaliException e) {
94494       {
94495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94496       };
94497     } catch (...) {
94498       {
94499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94500       };
94501     }
94502   }
94503
94504 }
94505
94506
94507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
94508   unsigned int jresult ;
94509   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
94510   bool result;
94511
94512   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
94513   {
94514     try {
94515       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);
94516     } catch (std::out_of_range& e) {
94517       {
94518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94519       };
94520     } catch (std::exception& e) {
94521       {
94522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94523       };
94524     } catch (Dali::DaliException e) {
94525       {
94526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94527       };
94528     } catch (...) {
94529       {
94530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94531       };
94532     }
94533   }
94534
94535   jresult = result;
94536   return jresult;
94537 }
94538
94539
94540 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
94541   unsigned long jresult ;
94542   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
94543   std::size_t result;
94544
94545   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
94546   {
94547     try {
94548       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);
94549     } catch (std::out_of_range& e) {
94550       {
94551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94552       };
94553     } catch (std::exception& e) {
94554       {
94555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94556       };
94557     } catch (Dali::DaliException e) {
94558       {
94559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94560       };
94561     } catch (...) {
94562       {
94563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94564       };
94565     }
94566   }
94567
94568   jresult = (unsigned long)result;
94569   return jresult;
94570 }
94571
94572
94573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
94574   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
94575   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
94576
94577   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
94578   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
94579   {
94580     try {
94581       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
94582     } catch (std::out_of_range& e) {
94583       {
94584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94585       };
94586     } catch (std::exception& e) {
94587       {
94588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94589       };
94590     } catch (Dali::DaliException e) {
94591       {
94592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94593       };
94594     } catch (...) {
94595       {
94596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94597       };
94598     }
94599   }
94600
94601 }
94602
94603
94604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
94605   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
94606   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
94607
94608   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
94609   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
94610   {
94611     try {
94612       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
94613     } catch (std::out_of_range& e) {
94614       {
94615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94616       };
94617     } catch (std::exception& e) {
94618       {
94619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94620       };
94621     } catch (Dali::DaliException e) {
94622       {
94623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94624       };
94625     } catch (...) {
94626       {
94627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94628       };
94629     }
94630   }
94631
94632 }
94633
94634
94635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
94636   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
94637   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
94638
94639   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
94640   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
94641   if (!arg2) {
94642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
94643     return ;
94644   }
94645   {
94646     try {
94647       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
94648     } catch (std::out_of_range& e) {
94649       {
94650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94651       };
94652     } catch (std::exception& e) {
94653       {
94654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94655       };
94656     } catch (Dali::DaliException e) {
94657       {
94658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94659       };
94660     } catch (...) {
94661       {
94662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94663       };
94664     }
94665   }
94666
94667 }
94668
94669
94670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
94671   void * jresult ;
94672   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
94673
94674   {
94675     try {
94676       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
94677     } catch (std::out_of_range& e) {
94678       {
94679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94680       };
94681     } catch (std::exception& e) {
94682       {
94683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94684       };
94685     } catch (Dali::DaliException e) {
94686       {
94687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94688       };
94689     } catch (...) {
94690       {
94691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94692       };
94693     }
94694   }
94695
94696   jresult = (void *)result;
94697   return jresult;
94698 }
94699
94700
94701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
94702   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
94703
94704   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
94705   {
94706     try {
94707       delete arg1;
94708     } catch (std::out_of_range& e) {
94709       {
94710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94711       };
94712     } catch (std::exception& e) {
94713       {
94714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94715       };
94716     } catch (Dali::DaliException e) {
94717       {
94718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94719       };
94720     } catch (...) {
94721       {
94722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94723       };
94724     }
94725   }
94726
94727 }
94728
94729
94730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
94731   unsigned int jresult ;
94732   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94733   bool result;
94734
94735   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94736   {
94737     try {
94738       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
94739     } catch (std::out_of_range& e) {
94740       {
94741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94742       };
94743     } catch (std::exception& e) {
94744       {
94745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94746       };
94747     } catch (Dali::DaliException e) {
94748       {
94749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94750       };
94751     } catch (...) {
94752       {
94753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94754       };
94755     }
94756   }
94757
94758   jresult = result;
94759   return jresult;
94760 }
94761
94762
94763 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
94764   unsigned long jresult ;
94765   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94766   std::size_t result;
94767
94768   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94769   {
94770     try {
94771       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
94772     } catch (std::out_of_range& e) {
94773       {
94774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94775       };
94776     } catch (std::exception& e) {
94777       {
94778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94779       };
94780     } catch (Dali::DaliException e) {
94781       {
94782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94783       };
94784     } catch (...) {
94785       {
94786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94787       };
94788     }
94789   }
94790
94791   jresult = (unsigned long)result;
94792   return jresult;
94793 }
94794
94795
94796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
94797   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94798   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
94799
94800   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94801   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
94802   {
94803     try {
94804       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
94805     } catch (std::out_of_range& e) {
94806       {
94807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94808       };
94809     } catch (std::exception& e) {
94810       {
94811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94812       };
94813     } catch (Dali::DaliException e) {
94814       {
94815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94816       };
94817     } catch (...) {
94818       {
94819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94820       };
94821     }
94822   }
94823
94824 }
94825
94826
94827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
94828   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94829   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
94830
94831   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94832   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
94833   {
94834     try {
94835       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
94836     } catch (std::out_of_range& e) {
94837       {
94838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94839       };
94840     } catch (std::exception& e) {
94841       {
94842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94843       };
94844     } catch (Dali::DaliException e) {
94845       {
94846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94847       };
94848     } catch (...) {
94849       {
94850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94851       };
94852     }
94853   }
94854
94855 }
94856
94857
94858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
94859   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94860   Dali::Vector2 *arg2 = 0 ;
94861
94862   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94863   arg2 = (Dali::Vector2 *)jarg2;
94864   if (!arg2) {
94865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
94866     return ;
94867   }
94868   {
94869     try {
94870       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
94871     } catch (std::out_of_range& e) {
94872       {
94873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94874       };
94875     } catch (std::exception& e) {
94876       {
94877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94878       };
94879     } catch (Dali::DaliException e) {
94880       {
94881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94882       };
94883     } catch (...) {
94884       {
94885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94886       };
94887     }
94888   }
94889
94890 }
94891
94892
94893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
94894   void * jresult ;
94895   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
94896
94897   {
94898     try {
94899       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
94900     } catch (std::out_of_range& e) {
94901       {
94902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94903       };
94904     } catch (std::exception& e) {
94905       {
94906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94907       };
94908     } catch (Dali::DaliException e) {
94909       {
94910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94911       };
94912     } catch (...) {
94913       {
94914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94915       };
94916     }
94917   }
94918
94919   jresult = (void *)result;
94920   return jresult;
94921 }
94922
94923
94924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
94925   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
94926
94927   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
94928   {
94929     try {
94930       delete arg1;
94931     } catch (std::out_of_range& e) {
94932       {
94933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94934       };
94935     } catch (std::exception& e) {
94936       {
94937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94938       };
94939     } catch (Dali::DaliException e) {
94940       {
94941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94942       };
94943     } catch (...) {
94944       {
94945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94946       };
94947     }
94948   }
94949
94950 }
94951
94952
94953
94954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
94955   unsigned int jresult ;
94956   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
94957   bool result;
94958
94959   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
94960   {
94961     try {
94962       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);
94963     } catch (std::out_of_range& e) {
94964       {
94965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94966       };
94967     } catch (std::exception& e) {
94968       {
94969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94970       };
94971     } catch (Dali::DaliException e) {
94972       {
94973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94974       };
94975     } catch (...) {
94976       {
94977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94978       };
94979     }
94980   }
94981
94982   jresult = result;
94983   return jresult;
94984 }
94985
94986
94987 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
94988   unsigned long jresult ;
94989   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
94990   std::size_t result;
94991
94992   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
94993   {
94994     try {
94995       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);
94996     } catch (std::out_of_range& e) {
94997       {
94998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94999       };
95000     } catch (std::exception& e) {
95001       {
95002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95003       };
95004     } catch (Dali::DaliException e) {
95005       {
95006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95007       };
95008     } catch (...) {
95009       {
95010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95011       };
95012     }
95013   }
95014
95015   jresult = (unsigned long)result;
95016   return jresult;
95017 }
95018
95019
95020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
95021   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
95022   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
95023
95024   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
95025   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
95026   {
95027     try {
95028       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
95029     } catch (std::out_of_range& e) {
95030       {
95031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95032       };
95033     } catch (std::exception& e) {
95034       {
95035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95036       };
95037     } catch (Dali::DaliException e) {
95038       {
95039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95040       };
95041     } catch (...) {
95042       {
95043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95044       };
95045     }
95046   }
95047
95048 }
95049
95050
95051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
95052   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
95053   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
95054
95055   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
95056   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
95057   {
95058     try {
95059       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
95060     } catch (std::out_of_range& e) {
95061       {
95062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95063       };
95064     } catch (std::exception& e) {
95065       {
95066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95067       };
95068     } catch (Dali::DaliException e) {
95069       {
95070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95071       };
95072     } catch (...) {
95073       {
95074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95075       };
95076     }
95077   }
95078
95079 }
95080
95081
95082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95083   unsigned int jresult ;
95084   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
95085   Dali::Toolkit::Control arg2 ;
95086   Dali::KeyEvent *arg3 = 0 ;
95087   Dali::Toolkit::Control *argp2 ;
95088   bool result;
95089
95090   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
95091   argp2 = (Dali::Toolkit::Control *)jarg2;
95092   if (!argp2) {
95093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95094     return 0;
95095   }
95096   arg2 = *argp2;
95097   arg3 = (Dali::KeyEvent *)jarg3;
95098   if (!arg3) {
95099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
95100     return 0;
95101   }
95102   {
95103     try {
95104       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);
95105     } catch (std::out_of_range& e) {
95106       {
95107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95108       };
95109     } catch (std::exception& e) {
95110       {
95111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95112       };
95113     } catch (Dali::DaliException e) {
95114       {
95115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95116       };
95117     } catch (...) {
95118       {
95119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95120       };
95121     }
95122   }
95123
95124   jresult = result;
95125   return jresult;
95126 }
95127
95128
95129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
95130   void * jresult ;
95131   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
95132
95133   {
95134     try {
95135       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
95136     } catch (std::out_of_range& e) {
95137       {
95138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95139       };
95140     } catch (std::exception& e) {
95141       {
95142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95143       };
95144     } catch (Dali::DaliException e) {
95145       {
95146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95147       };
95148     } catch (...) {
95149       {
95150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95151       };
95152     }
95153   }
95154
95155   jresult = (void *)result;
95156   return jresult;
95157 }
95158
95159
95160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
95161   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
95162
95163   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
95164   {
95165     try {
95166       delete arg1;
95167     } catch (std::out_of_range& e) {
95168       {
95169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95170       };
95171     } catch (std::exception& e) {
95172       {
95173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95174       };
95175     } catch (Dali::DaliException e) {
95176       {
95177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95178       };
95179     } catch (...) {
95180       {
95181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95182       };
95183     }
95184   }
95185
95186 }
95187
95188
95189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
95190   unsigned int jresult ;
95191   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95192   bool result;
95193
95194   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95195   {
95196     try {
95197       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95198     } catch (std::out_of_range& e) {
95199       {
95200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95201       };
95202     } catch (std::exception& e) {
95203       {
95204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95205       };
95206     } catch (Dali::DaliException e) {
95207       {
95208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95209       };
95210     } catch (...) {
95211       {
95212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95213       };
95214     }
95215   }
95216
95217   jresult = result;
95218   return jresult;
95219 }
95220
95221
95222 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
95223   unsigned long jresult ;
95224   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95225   std::size_t result;
95226
95227   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95228   {
95229     try {
95230       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95231     } catch (std::out_of_range& e) {
95232       {
95233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95234       };
95235     } catch (std::exception& e) {
95236       {
95237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95238       };
95239     } catch (Dali::DaliException e) {
95240       {
95241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95242       };
95243     } catch (...) {
95244       {
95245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95246       };
95247     }
95248   }
95249
95250   jresult = (unsigned long)result;
95251   return jresult;
95252 }
95253
95254
95255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
95256   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95257   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95258
95259   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95260   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95261   {
95262     try {
95263       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95264     } catch (std::out_of_range& e) {
95265       {
95266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95267       };
95268     } catch (std::exception& e) {
95269       {
95270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95271       };
95272     } catch (Dali::DaliException e) {
95273       {
95274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95275       };
95276     } catch (...) {
95277       {
95278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95279       };
95280     }
95281   }
95282
95283 }
95284
95285
95286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
95287   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95288   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95289
95290   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95291   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95292   {
95293     try {
95294       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95295     } catch (std::out_of_range& e) {
95296       {
95297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95298       };
95299     } catch (std::exception& e) {
95300       {
95301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95302       };
95303     } catch (Dali::DaliException e) {
95304       {
95305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95306       };
95307     } catch (...) {
95308       {
95309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95310       };
95311     }
95312   }
95313
95314 }
95315
95316
95317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
95318   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95319   Dali::Toolkit::Control arg2 ;
95320   Dali::Toolkit::Control *argp2 ;
95321
95322   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95323   argp2 = (Dali::Toolkit::Control *)jarg2;
95324   if (!argp2) {
95325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95326     return ;
95327   }
95328   arg2 = *argp2;
95329   {
95330     try {
95331       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95332     } catch (std::out_of_range& e) {
95333       {
95334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95335       };
95336     } catch (std::exception& e) {
95337       {
95338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95339       };
95340     } catch (Dali::DaliException e) {
95341       {
95342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95343       };
95344     } catch (...) {
95345       {
95346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95347       };
95348     }
95349   }
95350
95351 }
95352
95353
95354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
95355   void * jresult ;
95356   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95357
95358   {
95359     try {
95360       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95361     } catch (std::out_of_range& e) {
95362       {
95363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95364       };
95365     } catch (std::exception& e) {
95366       {
95367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95368       };
95369     } catch (Dali::DaliException e) {
95370       {
95371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95372       };
95373     } catch (...) {
95374       {
95375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95376       };
95377     }
95378   }
95379
95380   jresult = (void *)result;
95381   return jresult;
95382 }
95383
95384
95385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
95386   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95387
95388   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95389   {
95390     try {
95391       delete arg1;
95392     } catch (std::out_of_range& e) {
95393       {
95394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95395       };
95396     } catch (std::exception& e) {
95397       {
95398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95399       };
95400     } catch (Dali::DaliException e) {
95401       {
95402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95403       };
95404     } catch (...) {
95405       {
95406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95407       };
95408     }
95409   }
95410
95411 }
95412
95413
95414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
95415   unsigned int jresult ;
95416   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
95417   bool result;
95418
95419   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
95420   {
95421     try {
95422       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
95423     } catch (std::out_of_range& e) {
95424       {
95425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95426       };
95427     } catch (std::exception& e) {
95428       {
95429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95430       };
95431     } catch (Dali::DaliException e) {
95432       {
95433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95434       };
95435     } catch (...) {
95436       {
95437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95438       };
95439     }
95440   }
95441
95442   jresult = result;
95443   return jresult;
95444 }
95445
95446
95447 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
95448   unsigned long jresult ;
95449   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
95450   std::size_t result;
95451
95452   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
95453   {
95454     try {
95455       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
95456     } catch (std::out_of_range& e) {
95457       {
95458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95459       };
95460     } catch (std::exception& e) {
95461       {
95462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95463       };
95464     } catch (Dali::DaliException e) {
95465       {
95466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95467       };
95468     } catch (...) {
95469       {
95470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95471       };
95472     }
95473   }
95474
95475   jresult = (unsigned long)result;
95476   return jresult;
95477 }
95478
95479
95480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
95481   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
95482   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
95483
95484   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
95485   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
95486   {
95487     try {
95488       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
95489     } catch (std::out_of_range& e) {
95490       {
95491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95492       };
95493     } catch (std::exception& e) {
95494       {
95495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95496       };
95497     } catch (Dali::DaliException e) {
95498       {
95499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95500       };
95501     } catch (...) {
95502       {
95503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95504       };
95505     }
95506   }
95507
95508 }
95509
95510
95511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
95512   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
95513   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
95514
95515   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
95516   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
95517   {
95518     try {
95519       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
95520     } catch (std::out_of_range& e) {
95521       {
95522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95523       };
95524     } catch (std::exception& e) {
95525       {
95526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95527       };
95528     } catch (Dali::DaliException e) {
95529       {
95530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95531       };
95532     } catch (...) {
95533       {
95534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95535       };
95536     }
95537   }
95538
95539 }
95540
95541
95542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
95543   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
95544   Dali::Toolkit::VideoView *arg2 = 0 ;
95545
95546   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
95547   arg2 = (Dali::Toolkit::VideoView *)jarg2;
95548   if (!arg2) {
95549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
95550     return ;
95551   }
95552   {
95553     try {
95554       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
95555     } catch (std::out_of_range& e) {
95556       {
95557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95558       };
95559     } catch (std::exception& e) {
95560       {
95561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95562       };
95563     } catch (Dali::DaliException e) {
95564       {
95565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95566       };
95567     } catch (...) {
95568       {
95569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95570       };
95571     }
95572   }
95573
95574 }
95575
95576
95577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
95578   void * jresult ;
95579   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
95580
95581   {
95582     try {
95583       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
95584     } catch (std::out_of_range& e) {
95585       {
95586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95587       };
95588     } catch (std::exception& e) {
95589       {
95590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95591       };
95592     } catch (Dali::DaliException e) {
95593       {
95594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95595       };
95596     } catch (...) {
95597       {
95598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95599       };
95600     }
95601   }
95602
95603   jresult = (void *)result;
95604   return jresult;
95605 }
95606
95607
95608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
95609   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
95610
95611   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
95612   {
95613     try {
95614       delete arg1;
95615     } catch (std::out_of_range& e) {
95616       {
95617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95618       };
95619     } catch (std::exception& e) {
95620       {
95621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95622       };
95623     } catch (Dali::DaliException e) {
95624       {
95625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95626       };
95627     } catch (...) {
95628       {
95629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95630       };
95631     }
95632   }
95633
95634 }
95635
95636
95637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
95638   unsigned int jresult ;
95639   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
95640   bool result;
95641
95642   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
95643   {
95644     try {
95645       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
95646     } catch (std::out_of_range& e) {
95647       {
95648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95649       };
95650     } catch (std::exception& e) {
95651       {
95652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95653       };
95654     } catch (Dali::DaliException e) {
95655       {
95656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95657       };
95658     } catch (...) {
95659       {
95660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95661       };
95662     }
95663   }
95664
95665   jresult = result;
95666   return jresult;
95667 }
95668
95669
95670 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
95671   unsigned long jresult ;
95672   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
95673   std::size_t result;
95674
95675   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
95676   {
95677     try {
95678       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
95679     } catch (std::out_of_range& e) {
95680       {
95681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95682       };
95683     } catch (std::exception& e) {
95684       {
95685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95686       };
95687     } catch (Dali::DaliException e) {
95688       {
95689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95690       };
95691     } catch (...) {
95692       {
95693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95694       };
95695     }
95696   }
95697
95698   jresult = (unsigned long)result;
95699   return jresult;
95700 }
95701
95702
95703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
95704   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
95705   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
95706
95707   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
95708   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
95709   {
95710     try {
95711       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
95712     } catch (std::out_of_range& e) {
95713       {
95714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95715       };
95716     } catch (std::exception& e) {
95717       {
95718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95719       };
95720     } catch (Dali::DaliException e) {
95721       {
95722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95723       };
95724     } catch (...) {
95725       {
95726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95727       };
95728     }
95729   }
95730
95731 }
95732
95733
95734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95735   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
95736   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
95737
95738   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
95739   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
95740   {
95741     try {
95742       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
95743     } catch (std::out_of_range& e) {
95744       {
95745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95746       };
95747     } catch (std::exception& e) {
95748       {
95749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95750       };
95751     } catch (Dali::DaliException e) {
95752       {
95753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95754       };
95755     } catch (...) {
95756       {
95757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95758       };
95759     }
95760   }
95761
95762 }
95763
95764
95765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
95766   unsigned int jresult ;
95767   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
95768   Dali::Toolkit::Slider arg2 ;
95769   float arg3 ;
95770   Dali::Toolkit::Slider *argp2 ;
95771   bool result;
95772
95773   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
95774   argp2 = (Dali::Toolkit::Slider *)jarg2;
95775   if (!argp2) {
95776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
95777     return 0;
95778   }
95779   arg2 = *argp2;
95780   arg3 = (float)jarg3;
95781   {
95782     try {
95783       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
95784     } catch (std::out_of_range& e) {
95785       {
95786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95787       };
95788     } catch (std::exception& e) {
95789       {
95790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95791       };
95792     } catch (Dali::DaliException e) {
95793       {
95794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95795       };
95796     } catch (...) {
95797       {
95798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95799       };
95800     }
95801   }
95802
95803   jresult = result;
95804   return jresult;
95805 }
95806
95807
95808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
95809   void * jresult ;
95810   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
95811
95812   {
95813     try {
95814       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
95815     } catch (std::out_of_range& e) {
95816       {
95817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95818       };
95819     } catch (std::exception& e) {
95820       {
95821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95822       };
95823     } catch (Dali::DaliException e) {
95824       {
95825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95826       };
95827     } catch (...) {
95828       {
95829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95830       };
95831     }
95832   }
95833
95834   jresult = (void *)result;
95835   return jresult;
95836 }
95837
95838
95839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
95840   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
95841
95842   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
95843   {
95844     try {
95845       delete arg1;
95846     } catch (std::out_of_range& e) {
95847       {
95848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95849       };
95850     } catch (std::exception& e) {
95851       {
95852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95853       };
95854     } catch (Dali::DaliException e) {
95855       {
95856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95857       };
95858     } catch (...) {
95859       {
95860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95861       };
95862     }
95863   }
95864
95865 }
95866
95867
95868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
95869   unsigned int jresult ;
95870   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95871   bool result;
95872
95873   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
95874   {
95875     try {
95876       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
95877     } catch (std::out_of_range& e) {
95878       {
95879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95880       };
95881     } catch (std::exception& e) {
95882       {
95883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95884       };
95885     } catch (Dali::DaliException e) {
95886       {
95887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95888       };
95889     } catch (...) {
95890       {
95891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95892       };
95893     }
95894   }
95895
95896   jresult = result;
95897   return jresult;
95898 }
95899
95900
95901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
95902   unsigned long jresult ;
95903   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95904   std::size_t result;
95905
95906   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
95907   {
95908     try {
95909       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
95910     } catch (std::out_of_range& e) {
95911       {
95912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95913       };
95914     } catch (std::exception& e) {
95915       {
95916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95917       };
95918     } catch (Dali::DaliException e) {
95919       {
95920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95921       };
95922     } catch (...) {
95923       {
95924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95925       };
95926     }
95927   }
95928
95929   jresult = (unsigned long)result;
95930   return jresult;
95931 }
95932
95933
95934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
95935   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95936   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
95937
95938   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
95939   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
95940   {
95941     try {
95942       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
95943     } catch (std::out_of_range& e) {
95944       {
95945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95946       };
95947     } catch (std::exception& e) {
95948       {
95949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95950       };
95951     } catch (Dali::DaliException e) {
95952       {
95953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95954       };
95955     } catch (...) {
95956       {
95957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95958       };
95959     }
95960   }
95961
95962 }
95963
95964
95965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
95966   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95967   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
95968
95969   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
95970   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
95971   {
95972     try {
95973       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
95974     } catch (std::out_of_range& e) {
95975       {
95976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95977       };
95978     } catch (std::exception& e) {
95979       {
95980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95981       };
95982     } catch (Dali::DaliException e) {
95983       {
95984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95985       };
95986     } catch (...) {
95987       {
95988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95989       };
95990     }
95991   }
95992
95993 }
95994
95995
95996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95997   unsigned int jresult ;
95998   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
95999   Dali::Toolkit::Slider arg2 ;
96000   int arg3 ;
96001   Dali::Toolkit::Slider *argp2 ;
96002   bool result;
96003
96004   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
96005   argp2 = (Dali::Toolkit::Slider *)jarg2;
96006   if (!argp2) {
96007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
96008     return 0;
96009   }
96010   arg2 = *argp2;
96011   arg3 = (int)jarg3;
96012   {
96013     try {
96014       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
96015     } catch (std::out_of_range& e) {
96016       {
96017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96018       };
96019     } catch (std::exception& e) {
96020       {
96021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96022       };
96023     } catch (Dali::DaliException e) {
96024       {
96025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96026       };
96027     } catch (...) {
96028       {
96029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96030       };
96031     }
96032   }
96033
96034   jresult = result;
96035   return jresult;
96036 }
96037
96038
96039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
96040   void * jresult ;
96041   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
96042
96043   {
96044     try {
96045       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
96046     } catch (std::out_of_range& e) {
96047       {
96048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96049       };
96050     } catch (std::exception& e) {
96051       {
96052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96053       };
96054     } catch (Dali::DaliException e) {
96055       {
96056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96057       };
96058     } catch (...) {
96059       {
96060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96061       };
96062     }
96063   }
96064
96065   jresult = (void *)result;
96066   return jresult;
96067 }
96068
96069
96070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
96071   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
96072
96073   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
96074   {
96075     try {
96076       delete arg1;
96077     } catch (std::out_of_range& e) {
96078       {
96079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96080       };
96081     } catch (std::exception& e) {
96082       {
96083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96084       };
96085     } catch (Dali::DaliException e) {
96086       {
96087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96088       };
96089     } catch (...) {
96090       {
96091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96092       };
96093     }
96094   }
96095
96096 }
96097
96098
96099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
96100   void * jresult ;
96101   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
96102
96103   {
96104     try {
96105       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
96106     } catch (std::out_of_range& e) {
96107       {
96108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96109       };
96110     } catch (std::exception& e) {
96111       {
96112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96113       };
96114     } catch (Dali::DaliException e) {
96115       {
96116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96117       };
96118     } catch (...) {
96119       {
96120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96121       };
96122     }
96123   }
96124
96125   jresult = (void *)result;
96126   return jresult;
96127 }
96128
96129
96130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
96131   void * jresult ;
96132   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
96133   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
96134
96135   arg1 = (Dali::Toolkit::Ruler *)jarg1;
96136   {
96137     try {
96138       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
96139     } catch (std::out_of_range& e) {
96140       {
96141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96142       };
96143     } catch (std::exception& e) {
96144       {
96145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96146       };
96147     } catch (Dali::DaliException e) {
96148       {
96149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96150       };
96151     } catch (...) {
96152       {
96153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96154       };
96155     }
96156   }
96157
96158   jresult = (void *)result;
96159   return jresult;
96160 }
96161
96162
96163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
96164   void * jresult ;
96165   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
96166   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
96167
96168   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96169   if (!arg1) {
96170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
96171     return 0;
96172   }
96173   {
96174     try {
96175       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
96176     } catch (std::out_of_range& e) {
96177       {
96178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96179       };
96180     } catch (std::exception& e) {
96181       {
96182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96183       };
96184     } catch (Dali::DaliException e) {
96185       {
96186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96187       };
96188     } catch (...) {
96189       {
96190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96191       };
96192     }
96193   }
96194
96195   jresult = (void *)result;
96196   return jresult;
96197 }
96198
96199
96200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
96201   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96202
96203   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96204   {
96205     try {
96206       delete arg1;
96207     } catch (std::out_of_range& e) {
96208       {
96209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96210       };
96211     } catch (std::exception& e) {
96212       {
96213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96214       };
96215     } catch (Dali::DaliException e) {
96216       {
96217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96218       };
96219     } catch (...) {
96220       {
96221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96222       };
96223     }
96224   }
96225
96226 }
96227
96228
96229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
96230   void * jresult ;
96231   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96232   Dali::Toolkit::Ruler *result = 0 ;
96233
96234   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96235   {
96236     try {
96237       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
96238     } catch (std::out_of_range& e) {
96239       {
96240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96241       };
96242     } catch (std::exception& e) {
96243       {
96244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96245       };
96246     } catch (Dali::DaliException e) {
96247       {
96248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96249       };
96250     } catch (...) {
96251       {
96252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96253       };
96254     }
96255   }
96256
96257   jresult = (void *)result;
96258   return jresult;
96259 }
96260
96261
96262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
96263   void * jresult ;
96264   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96265   Dali::Toolkit::Ruler *result = 0 ;
96266
96267   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96268   {
96269     try {
96270       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
96271     } catch (std::out_of_range& e) {
96272       {
96273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96274       };
96275     } catch (std::exception& e) {
96276       {
96277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96278       };
96279     } catch (Dali::DaliException e) {
96280       {
96281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96282       };
96283     } catch (...) {
96284       {
96285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96286       };
96287     }
96288   }
96289
96290   jresult = (void *)result;
96291   return jresult;
96292 }
96293
96294
96295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
96296   void * jresult ;
96297   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96298   Dali::Toolkit::Ruler *result = 0 ;
96299
96300   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96301   {
96302     try {
96303       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
96304     } catch (std::out_of_range& e) {
96305       {
96306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96307       };
96308     } catch (std::exception& e) {
96309       {
96310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96311       };
96312     } catch (Dali::DaliException e) {
96313       {
96314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96315       };
96316     } catch (...) {
96317       {
96318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96319       };
96320     }
96321   }
96322
96323   jresult = (void *)result;
96324   return jresult;
96325 }
96326
96327
96328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
96329   void * jresult ;
96330   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96331   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
96332   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
96333
96334   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96335   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
96336   if (!arg2) {
96337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
96338     return 0;
96339   }
96340   {
96341     try {
96342       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
96343     } catch (std::out_of_range& e) {
96344       {
96345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96346       };
96347     } catch (std::exception& e) {
96348       {
96349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96350       };
96351     } catch (Dali::DaliException e) {
96352       {
96353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96354       };
96355     } catch (...) {
96356       {
96357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96358       };
96359     }
96360   }
96361
96362   jresult = (void *)result;
96363   return jresult;
96364 }
96365
96366
96367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
96368   void * jresult ;
96369   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96370   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
96371   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
96372
96373   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96374   arg2 = (Dali::Toolkit::Ruler *)jarg2;
96375   {
96376     try {
96377       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
96378     } catch (std::out_of_range& e) {
96379       {
96380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96381       };
96382     } catch (std::exception& e) {
96383       {
96384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96385       };
96386     } catch (Dali::DaliException e) {
96387       {
96388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96389       };
96390     } catch (...) {
96391       {
96392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96393       };
96394     }
96395   }
96396
96397   jresult = (void *)result;
96398   return jresult;
96399 }
96400
96401
96402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
96403   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96404
96405   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96406   {
96407     try {
96408       (arg1)->Reset();
96409     } catch (std::out_of_range& e) {
96410       {
96411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96412       };
96413     } catch (std::exception& e) {
96414       {
96415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96416       };
96417     } catch (Dali::DaliException e) {
96418       {
96419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96420       };
96421     } catch (...) {
96422       {
96423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96424       };
96425     }
96426   }
96427
96428 }
96429
96430
96431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
96432   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96433   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
96434
96435   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96436   arg2 = (Dali::Toolkit::Ruler *)jarg2;
96437   {
96438     try {
96439       (arg1)->Reset(arg2);
96440     } catch (std::out_of_range& e) {
96441       {
96442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96443       };
96444     } catch (std::exception& e) {
96445       {
96446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96447       };
96448     } catch (Dali::DaliException e) {
96449       {
96450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96451       };
96452     } catch (...) {
96453       {
96454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96455       };
96456     }
96457   }
96458
96459 }
96460
96461
96462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
96463   void * jresult ;
96464   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96465   Dali::Toolkit::Ruler *result = 0 ;
96466
96467   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96468   {
96469     try {
96470       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
96471     } catch (std::out_of_range& e) {
96472       {
96473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96474       };
96475     } catch (std::exception& e) {
96476       {
96477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96478       };
96479     } catch (Dali::DaliException e) {
96480       {
96481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96482       };
96483     } catch (...) {
96484       {
96485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96486       };
96487     }
96488   }
96489
96490   jresult = (void *)result;
96491   return jresult;
96492 }
96493
96494
96495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
96496   float jresult ;
96497   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96498   float arg2 ;
96499   float arg3 ;
96500   float result;
96501
96502   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96503   arg2 = (float)jarg2;
96504   arg3 = (float)jarg3;
96505   {
96506     try {
96507       result = (float)(*arg1)->Snap(arg2,arg3);
96508     } catch (std::out_of_range& e) {
96509       {
96510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96511       };
96512     } catch (std::exception& e) {
96513       {
96514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96515       };
96516     } catch (Dali::DaliException e) {
96517       {
96518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96519       };
96520     } catch (...) {
96521       {
96522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96523       };
96524     }
96525   }
96526
96527   jresult = result;
96528   return jresult;
96529 }
96530
96531
96532 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
96533   float jresult ;
96534   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96535   float arg2 ;
96536   float result;
96537
96538   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96539   arg2 = (float)jarg2;
96540   {
96541     try {
96542       result = (float)(*arg1)->Snap(arg2);
96543     } catch (std::out_of_range& e) {
96544       {
96545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96546       };
96547     } catch (std::exception& e) {
96548       {
96549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96550       };
96551     } catch (Dali::DaliException e) {
96552       {
96553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96554       };
96555     } catch (...) {
96556       {
96557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96558       };
96559     }
96560   }
96561
96562   jresult = result;
96563   return jresult;
96564 }
96565
96566
96567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
96568   float jresult ;
96569   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96570   unsigned int arg2 ;
96571   unsigned int *arg3 = 0 ;
96572   bool arg4 ;
96573   float result;
96574
96575   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96576   arg2 = (unsigned int)jarg2;
96577   arg3 = (unsigned int *)jarg3;
96578   arg4 = jarg4 ? true : false;
96579   {
96580     try {
96581       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
96582     } catch (std::out_of_range& e) {
96583       {
96584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96585       };
96586     } catch (std::exception& e) {
96587       {
96588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96589       };
96590     } catch (Dali::DaliException e) {
96591       {
96592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96593       };
96594     } catch (...) {
96595       {
96596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96597       };
96598     }
96599   }
96600
96601   jresult = result;
96602   return jresult;
96603 }
96604
96605
96606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
96607   unsigned int jresult ;
96608   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96609   float arg2 ;
96610   bool arg3 ;
96611   unsigned int result;
96612
96613   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96614   arg2 = (float)jarg2;
96615   arg3 = jarg3 ? true : false;
96616   {
96617     try {
96618       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
96619     } catch (std::out_of_range& e) {
96620       {
96621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96622       };
96623     } catch (std::exception& e) {
96624       {
96625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96626       };
96627     } catch (Dali::DaliException e) {
96628       {
96629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96630       };
96631     } catch (...) {
96632       {
96633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96634       };
96635     }
96636   }
96637
96638   jresult = result;
96639   return jresult;
96640 }
96641
96642
96643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
96644   unsigned int jresult ;
96645   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96646   unsigned int result;
96647
96648   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96649   {
96650     try {
96651       result = (unsigned int)(*arg1)->GetTotalPages();
96652     } catch (std::out_of_range& e) {
96653       {
96654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96655       };
96656     } catch (std::exception& e) {
96657       {
96658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96659       };
96660     } catch (Dali::DaliException e) {
96661       {
96662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96663       };
96664     } catch (...) {
96665       {
96666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96667       };
96668     }
96669   }
96670
96671   jresult = result;
96672   return jresult;
96673 }
96674
96675
96676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
96677   int jresult ;
96678   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96679   Dali::Toolkit::Ruler::RulerType result;
96680
96681   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96682   {
96683     try {
96684       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
96685     } catch (std::out_of_range& e) {
96686       {
96687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96688       };
96689     } catch (std::exception& e) {
96690       {
96691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96692       };
96693     } catch (Dali::DaliException e) {
96694       {
96695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96696       };
96697     } catch (...) {
96698       {
96699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96700       };
96701     }
96702   }
96703
96704   jresult = (int)result;
96705   return jresult;
96706 }
96707
96708
96709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
96710   unsigned int jresult ;
96711   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96712   bool result;
96713
96714   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96715   {
96716     try {
96717       result = (bool)(*arg1)->IsEnabled();
96718     } catch (std::out_of_range& e) {
96719       {
96720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96721       };
96722     } catch (std::exception& e) {
96723       {
96724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96725       };
96726     } catch (Dali::DaliException e) {
96727       {
96728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96729       };
96730     } catch (...) {
96731       {
96732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96733       };
96734     }
96735   }
96736
96737   jresult = result;
96738   return jresult;
96739 }
96740
96741
96742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
96743   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96744
96745   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96746   {
96747     try {
96748       (*arg1)->Enable();
96749     } catch (std::out_of_range& e) {
96750       {
96751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96752       };
96753     } catch (std::exception& e) {
96754       {
96755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96756       };
96757     } catch (Dali::DaliException e) {
96758       {
96759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96760       };
96761     } catch (...) {
96762       {
96763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96764       };
96765     }
96766   }
96767
96768 }
96769
96770
96771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
96772   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96773
96774   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96775   {
96776     try {
96777       (*arg1)->Disable();
96778     } catch (std::out_of_range& e) {
96779       {
96780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96781       };
96782     } catch (std::exception& e) {
96783       {
96784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96785       };
96786     } catch (Dali::DaliException e) {
96787       {
96788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96789       };
96790     } catch (...) {
96791       {
96792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96793       };
96794     }
96795   }
96796
96797 }
96798
96799
96800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
96801   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96802   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
96803   Dali::Toolkit::RulerDomain *argp2 ;
96804
96805   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96806   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
96807   if (!argp2) {
96808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
96809     return ;
96810   }
96811   arg2 = *argp2;
96812   {
96813     try {
96814       (*arg1)->SetDomain(arg2);
96815     } catch (std::out_of_range& e) {
96816       {
96817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96818       };
96819     } catch (std::exception& e) {
96820       {
96821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96822       };
96823     } catch (Dali::DaliException e) {
96824       {
96825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96826       };
96827     } catch (...) {
96828       {
96829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96830       };
96831     }
96832   }
96833
96834 }
96835
96836
96837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
96838   void * jresult ;
96839   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96840   Dali::Toolkit::RulerDomain *result = 0 ;
96841
96842   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96843   {
96844     try {
96845       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
96846     } catch (std::out_of_range& e) {
96847       {
96848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96849       };
96850     } catch (std::exception& e) {
96851       {
96852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96853       };
96854     } catch (Dali::DaliException e) {
96855       {
96856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96857       };
96858     } catch (...) {
96859       {
96860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96861       };
96862     }
96863   }
96864
96865   jresult = (void *)result;
96866   return jresult;
96867 }
96868
96869
96870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
96871   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96872
96873   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96874   {
96875     try {
96876       (*arg1)->DisableDomain();
96877     } catch (std::out_of_range& e) {
96878       {
96879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96880       };
96881     } catch (std::exception& e) {
96882       {
96883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96884       };
96885     } catch (Dali::DaliException e) {
96886       {
96887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96888       };
96889     } catch (...) {
96890       {
96891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96892       };
96893     }
96894   }
96895
96896 }
96897
96898
96899 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
96900   float jresult ;
96901   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96902   float arg2 ;
96903   float arg3 ;
96904   float arg4 ;
96905   float result;
96906
96907   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96908   arg2 = (float)jarg2;
96909   arg3 = (float)jarg3;
96910   arg4 = (float)jarg4;
96911   {
96912     try {
96913       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
96914     } catch (std::out_of_range& e) {
96915       {
96916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96917       };
96918     } catch (std::exception& e) {
96919       {
96920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96921       };
96922     } catch (Dali::DaliException e) {
96923       {
96924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96925       };
96926     } catch (...) {
96927       {
96928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96929       };
96930     }
96931   }
96932
96933   jresult = result;
96934   return jresult;
96935 }
96936
96937
96938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
96939   float jresult ;
96940   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96941   float arg2 ;
96942   float arg3 ;
96943   float result;
96944
96945   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96946   arg2 = (float)jarg2;
96947   arg3 = (float)jarg3;
96948   {
96949     try {
96950       result = (float)(*arg1)->Clamp(arg2,arg3);
96951     } catch (std::out_of_range& e) {
96952       {
96953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96954       };
96955     } catch (std::exception& e) {
96956       {
96957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96958       };
96959     } catch (Dali::DaliException e) {
96960       {
96961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96962       };
96963     } catch (...) {
96964       {
96965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96966       };
96967     }
96968   }
96969
96970   jresult = result;
96971   return jresult;
96972 }
96973
96974
96975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
96976   float jresult ;
96977   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96978   float arg2 ;
96979   float result;
96980
96981   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96982   arg2 = (float)jarg2;
96983   {
96984     try {
96985       result = (float)(*arg1)->Clamp(arg2);
96986     } catch (std::out_of_range& e) {
96987       {
96988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96989       };
96990     } catch (std::exception& e) {
96991       {
96992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96993       };
96994     } catch (Dali::DaliException e) {
96995       {
96996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96997       };
96998     } catch (...) {
96999       {
97000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97001       };
97002     }
97003   }
97004
97005   jresult = result;
97006   return jresult;
97007 }
97008
97009
97010 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
97011   float jresult ;
97012   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97013   float arg2 ;
97014   float arg3 ;
97015   float arg4 ;
97016   Dali::Toolkit::ClampState *arg5 = 0 ;
97017   float result;
97018
97019   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97020   arg2 = (float)jarg2;
97021   arg3 = (float)jarg3;
97022   arg4 = (float)jarg4;
97023   arg5 = (Dali::Toolkit::ClampState *)jarg5;
97024   if (!arg5) {
97025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
97026     return 0;
97027   }
97028   {
97029     try {
97030       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
97031     } catch (std::out_of_range& e) {
97032       {
97033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97034       };
97035     } catch (std::exception& e) {
97036       {
97037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97038       };
97039     } catch (Dali::DaliException e) {
97040       {
97041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97042       };
97043     } catch (...) {
97044       {
97045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97046       };
97047     }
97048   }
97049
97050   jresult = result;
97051   return jresult;
97052 }
97053
97054
97055 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
97056   float jresult ;
97057   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97058   float arg2 ;
97059   float arg3 ;
97060   float arg4 ;
97061   float arg5 ;
97062   float result;
97063
97064   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97065   arg2 = (float)jarg2;
97066   arg3 = (float)jarg3;
97067   arg4 = (float)jarg4;
97068   arg5 = (float)jarg5;
97069   {
97070     try {
97071       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
97072     } catch (std::out_of_range& e) {
97073       {
97074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97075       };
97076     } catch (std::exception& e) {
97077       {
97078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97079       };
97080     } catch (Dali::DaliException e) {
97081       {
97082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97083       };
97084     } catch (...) {
97085       {
97086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97087       };
97088     }
97089   }
97090
97091   jresult = result;
97092   return jresult;
97093 }
97094
97095
97096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
97097   float jresult ;
97098   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97099   float arg2 ;
97100   float arg3 ;
97101   float arg4 ;
97102   float result;
97103
97104   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97105   arg2 = (float)jarg2;
97106   arg3 = (float)jarg3;
97107   arg4 = (float)jarg4;
97108   {
97109     try {
97110       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
97111     } catch (std::out_of_range& e) {
97112       {
97113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97114       };
97115     } catch (std::exception& e) {
97116       {
97117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97118       };
97119     } catch (Dali::DaliException e) {
97120       {
97121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97122       };
97123     } catch (...) {
97124       {
97125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97126       };
97127     }
97128   }
97129
97130   jresult = result;
97131   return jresult;
97132 }
97133
97134
97135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
97136   float jresult ;
97137   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97138   float arg2 ;
97139   float arg3 ;
97140   float result;
97141
97142   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97143   arg2 = (float)jarg2;
97144   arg3 = (float)jarg3;
97145   {
97146     try {
97147       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
97148     } catch (std::out_of_range& e) {
97149       {
97150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97151       };
97152     } catch (std::exception& e) {
97153       {
97154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97155       };
97156     } catch (Dali::DaliException e) {
97157       {
97158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97159       };
97160     } catch (...) {
97161       {
97162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97163       };
97164     }
97165   }
97166
97167   jresult = result;
97168   return jresult;
97169 }
97170
97171
97172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
97173   float jresult ;
97174   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97175   float arg2 ;
97176   float result;
97177
97178   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97179   arg2 = (float)jarg2;
97180   {
97181     try {
97182       result = (float)(*arg1)->SnapAndClamp(arg2);
97183     } catch (std::out_of_range& e) {
97184       {
97185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97186       };
97187     } catch (std::exception& e) {
97188       {
97189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97190       };
97191     } catch (Dali::DaliException e) {
97192       {
97193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97194       };
97195     } catch (...) {
97196       {
97197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97198       };
97199     }
97200   }
97201
97202   jresult = result;
97203   return jresult;
97204 }
97205
97206
97207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
97208   float jresult ;
97209   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97210   float arg2 ;
97211   float arg3 ;
97212   float arg4 ;
97213   float arg5 ;
97214   Dali::Toolkit::ClampState *arg6 = 0 ;
97215   float result;
97216
97217   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97218   arg2 = (float)jarg2;
97219   arg3 = (float)jarg3;
97220   arg4 = (float)jarg4;
97221   arg5 = (float)jarg5;
97222   arg6 = (Dali::Toolkit::ClampState *)jarg6;
97223   if (!arg6) {
97224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
97225     return 0;
97226   }
97227   {
97228     try {
97229       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
97230     } catch (std::out_of_range& e) {
97231       {
97232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97233       };
97234     } catch (std::exception& e) {
97235       {
97236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97237       };
97238     } catch (Dali::DaliException e) {
97239       {
97240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97241       };
97242     } catch (...) {
97243       {
97244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97245       };
97246     }
97247   }
97248
97249   jresult = result;
97250   return jresult;
97251 }
97252
97253
97254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
97255   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97256
97257   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97258   {
97259     try {
97260       (*arg1)->Reference();
97261     } catch (std::out_of_range& e) {
97262       {
97263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97264       };
97265     } catch (std::exception& e) {
97266       {
97267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97268       };
97269     } catch (Dali::DaliException e) {
97270       {
97271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97272       };
97273     } catch (...) {
97274       {
97275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97276       };
97277     }
97278   }
97279
97280 }
97281
97282
97283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
97284   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97285
97286   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97287   {
97288     try {
97289       (*arg1)->Unreference();
97290     } catch (std::out_of_range& e) {
97291       {
97292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97293       };
97294     } catch (std::exception& e) {
97295       {
97296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97297       };
97298     } catch (Dali::DaliException e) {
97299       {
97300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97301       };
97302     } catch (...) {
97303       {
97304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97305       };
97306     }
97307   }
97308
97309 }
97310
97311
97312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
97313   int jresult ;
97314   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97315   int result;
97316
97317   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97318   {
97319     try {
97320       result = (int)(*arg1)->ReferenceCount();
97321     } catch (std::out_of_range& e) {
97322       {
97323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97324       };
97325     } catch (std::exception& e) {
97326       {
97327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97328       };
97329     } catch (Dali::DaliException e) {
97330       {
97331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97332       };
97333     } catch (...) {
97334       {
97335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97336       };
97337     }
97338   }
97339
97340   jresult = result;
97341   return jresult;
97342 }
97343
97344
97345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
97346   unsigned int jresult ;
97347   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97348   bool result;
97349
97350   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97351   {
97352     try {
97353       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97354     } catch (std::out_of_range& e) {
97355       {
97356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97357       };
97358     } catch (std::exception& e) {
97359       {
97360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97361       };
97362     } catch (Dali::DaliException e) {
97363       {
97364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97365       };
97366     } catch (...) {
97367       {
97368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97369       };
97370     }
97371   }
97372
97373   jresult = result;
97374   return jresult;
97375 }
97376
97377
97378 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
97379   unsigned long jresult ;
97380   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97381   std::size_t result;
97382
97383   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97384   {
97385     try {
97386       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97387     } catch (std::out_of_range& e) {
97388       {
97389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97390       };
97391     } catch (std::exception& e) {
97392       {
97393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97394       };
97395     } catch (Dali::DaliException e) {
97396       {
97397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97398       };
97399     } catch (...) {
97400       {
97401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97402       };
97403     }
97404   }
97405
97406   jresult = (unsigned long)result;
97407   return jresult;
97408 }
97409
97410
97411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
97412   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97413   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97414
97415   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97416   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97417   {
97418     try {
97419       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97420     } catch (std::out_of_range& e) {
97421       {
97422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97423       };
97424     } catch (std::exception& e) {
97425       {
97426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97427       };
97428     } catch (Dali::DaliException e) {
97429       {
97430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97431       };
97432     } catch (...) {
97433       {
97434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97435       };
97436     }
97437   }
97438
97439 }
97440
97441
97442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
97443   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97444   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97445
97446   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97447   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97448   {
97449     try {
97450       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
97451     } catch (std::out_of_range& e) {
97452       {
97453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97454       };
97455     } catch (std::exception& e) {
97456       {
97457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97458       };
97459     } catch (Dali::DaliException e) {
97460       {
97461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97462       };
97463     } catch (...) {
97464       {
97465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97466       };
97467     }
97468   }
97469
97470 }
97471
97472
97473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
97474   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97475   Dali::Toolkit::Control arg2 ;
97476   Dali::Toolkit::Control *argp2 ;
97477
97478   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97479   argp2 = (Dali::Toolkit::Control *)jarg2;
97480   if (!argp2) {
97481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97482     return ;
97483   }
97484   arg2 = *argp2;
97485   {
97486     try {
97487       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
97488     } catch (std::out_of_range& e) {
97489       {
97490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97491       };
97492     } catch (std::exception& e) {
97493       {
97494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97495       };
97496     } catch (Dali::DaliException e) {
97497       {
97498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97499       };
97500     } catch (...) {
97501       {
97502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97503       };
97504     }
97505   }
97506
97507 }
97508
97509
97510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
97511   void * jresult ;
97512   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
97513
97514   {
97515     try {
97516       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
97517     } catch (std::out_of_range& e) {
97518       {
97519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97520       };
97521     } catch (std::exception& e) {
97522       {
97523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97524       };
97525     } catch (Dali::DaliException e) {
97526       {
97527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97528       };
97529     } catch (...) {
97530       {
97531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97532       };
97533     }
97534   }
97535
97536   jresult = (void *)result;
97537   return jresult;
97538 }
97539
97540
97541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
97542   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97543
97544   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97545   {
97546     try {
97547       delete arg1;
97548     } catch (std::out_of_range& e) {
97549       {
97550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97551       };
97552     } catch (std::exception& e) {
97553       {
97554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97555       };
97556     } catch (Dali::DaliException e) {
97557       {
97558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97559       };
97560     } catch (...) {
97561       {
97562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97563       };
97564     }
97565   }
97566
97567 }
97568
97569 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
97570   Dali::RefObject *result = NULL;
97571
97572   if (arg1)
97573   {
97574     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
97575   }
97576   return result;
97577 }
97578
97579 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
97580     return (Dali::RefObject *)jarg1;
97581 }
97582
97583 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
97584     return (Dali::SignalObserver *)jarg1;
97585 }
97586
97587 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
97588     return (Dali::ConnectionTrackerInterface *)jarg1;
97589 }
97590
97591 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
97592     return (Dali::BaseHandle *)jarg1;
97593 }
97594
97595 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
97596     return (Dali::BaseHandle *)jarg1;
97597 }
97598
97599 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
97600     return (Dali::BaseHandle *)jarg1;
97601 }
97602
97603 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
97604     return (Dali::BaseHandle *)jarg1;
97605 }
97606
97607 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
97608     return (Dali::BaseHandle *)jarg1;
97609 }
97610
97611 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
97612     return (Dali::BaseHandle *)jarg1;
97613 }
97614
97615 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
97616     return (Dali::BaseHandle *)jarg1;
97617 }
97618
97619 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
97620     return (Dali::BaseHandle *)jarg1;
97621 }
97622
97623 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
97624     return (Dali::BaseHandle *)jarg1;
97625 }
97626
97627 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
97628     return (Dali::BaseHandle *)jarg1;
97629 }
97630
97631 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
97632     return (Dali::BaseHandle *)jarg1;
97633 }
97634
97635 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
97636     return (Dali::BaseHandle *)jarg1;
97637 }
97638
97639 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
97640     return (Dali::Handle *)jarg1;
97641 }
97642
97643 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
97644     return (Dali::Handle *)jarg1;
97645 }
97646
97647 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
97648     return (Dali::BaseHandle *)jarg1;
97649 }
97650
97651 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
97652     return (Dali::BaseHandle *)jarg1;
97653 }
97654
97655 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
97656     return (Dali::Handle *)jarg1;
97657 }
97658
97659 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
97660     return (Dali::BaseHandle *)jarg1;
97661 }
97662
97663 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
97664     return (Dali::Handle *)jarg1;
97665 }
97666
97667 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
97668     return (Dali::GestureDetector *)jarg1;
97669 }
97670
97671 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
97672     return (Dali::Gesture *)jarg1;
97673 }
97674
97675 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
97676     return (Dali::Handle *)jarg1;
97677 }
97678
97679 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
97680     return (Dali::Actor *)jarg1;
97681 }
97682
97683 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
97684     return (Dali::BaseHandle *)jarg1;
97685 }
97686
97687 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
97688     return (Dali::RefObject *)jarg1;
97689 }
97690
97691 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
97692     return (Dali::Actor *)jarg1;
97693 }
97694
97695 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
97696     return (Dali::GestureDetector *)jarg1;
97697 }
97698
97699 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
97700     return (Dali::Gesture *)jarg1;
97701 }
97702
97703 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
97704     return (Dali::GestureDetector *)jarg1;
97705 }
97706
97707 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
97708     return (Dali::Gesture *)jarg1;
97709 }
97710
97711 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
97712     return (Dali::GestureDetector *)jarg1;
97713 }
97714
97715 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
97716     return (Dali::Gesture *)jarg1;
97717 }
97718
97719 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
97720     return (Dali::BaseHandle *)jarg1;
97721 }
97722
97723 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
97724     return (Dali::Handle *)jarg1;
97725 }
97726
97727 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
97728     return (Dali::Handle *)jarg1;
97729 }
97730
97731 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
97732     return (Dali::Handle *)jarg1;
97733 }
97734
97735 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
97736     return (Dali::RefObject *)jarg1;
97737 }
97738
97739 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
97740     return (Dali::Actor *)jarg1;
97741 }
97742
97743 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
97744     return (Dali::BaseHandle *)jarg1;
97745 }
97746
97747 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
97748     return (Dali::BaseHandle *)jarg1;
97749 }
97750
97751 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
97752     return (Dali::BaseHandle *)jarg1;
97753 }
97754
97755 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
97756     return (Dali::CustomActorImpl *)jarg1;
97757 }
97758
97759 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
97760     return (Dali::CustomActor *)jarg1;
97761 }
97762
97763 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
97764     return (Dali::BaseHandle *)jarg1;
97765 }
97766
97767 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
97768     return (Dali::Toolkit::Control *)jarg1;
97769 }
97770
97771 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
97772     return (Dali::Toolkit::Control *)jarg1;
97773 }
97774
97775 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
97776     return (Dali::Toolkit::Button *)jarg1;
97777 }
97778
97779 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
97780     return (Dali::Toolkit::Button *)jarg1;
97781 }
97782
97783 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
97784     return (Dali::Toolkit::Button *)jarg1;
97785 }
97786
97787 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
97788     return (Dali::Toolkit::Control *)jarg1;
97789 }
97790
97791 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
97792     return (Dali::Toolkit::Control *)jarg1;
97793 }
97794
97795 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
97796     return (Dali::Toolkit::Control *)jarg1;
97797 }
97798
97799 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
97800     return (Dali::Toolkit::Control *)jarg1;
97801 }
97802
97803 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
97804     return (Dali::Toolkit::Control *)jarg1;
97805 }
97806
97807 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
97808     return (Dali::RefObject *)jarg1;
97809 }
97810
97811 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
97812     return (Dali::Toolkit::Scrollable *)jarg1;
97813 }
97814
97815 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
97816     return (Dali::BaseHandle *)jarg1;
97817 }
97818
97819 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
97820     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
97821 }
97822
97823 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
97824     return (Dali::RefObject *)jarg1;
97825 }
97826
97827 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
97828     return (Dali::Toolkit::Ruler *)jarg1;
97829 }
97830
97831 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
97832     return (Dali::Toolkit::Ruler *)jarg1;
97833 }
97834
97835 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
97836     return (Dali::Toolkit::Scrollable *)jarg1;
97837 }
97838
97839 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
97840     return (Dali::Toolkit::Control *)jarg1;
97841 }
97842
97843
97844 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
97845     return (Dali::Toolkit::Control *)jarg1;
97846 }
97847
97848 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
97849     return (Dali::BaseHandle *)jarg1;
97850 }
97851
97852 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
97853     return (Dali::BaseHandle *)jarg1;
97854 }
97855
97856 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
97857     return (Dali::Toolkit::Control *)jarg1;
97858 }
97859
97860 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
97861     return (Dali::Toolkit::Control *)jarg1;
97862 }
97863
97864 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
97865     return (Dali::Toolkit::Control *)jarg1;
97866 }
97867
97868 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
97869     return (Dali::Toolkit::Control *)jarg1;
97870 }
97871
97872 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
97873     return (Dali::Toolkit::Control *)jarg1;
97874 }
97875
97876 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
97877     return (Dali::Toolkit::Control *)jarg1;
97878 }
97879
97880 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
97881     return (Dali::Toolkit::PageTurnView *)jarg1;
97882 }
97883
97884 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
97885     return (Dali::Toolkit::PageTurnView *)jarg1;
97886 }
97887
97888 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
97889     return (Dali::Toolkit::Button *)jarg1;
97890 }
97891
97892 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
97893     return (Dali::BaseHandle *)jarg1;
97894 }
97895
97896 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
97897     return (Dali::BaseHandle *)jarg1;
97898 }
97899
97900 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
97901     return (Dali::BaseHandle *)jarg1;
97902 }
97903
97904 /*
97905  * Widget binding
97906  */
97907 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
97908     return (Dali::BaseHandle *)jarg1;
97909 }
97910
97911 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
97912     return (Dali::BaseObject *)jarg1;
97913 }
97914
97915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
97916   void * jresult ;
97917   Dali::Widget result;
97918
97919   {
97920     try {
97921       result = Dali::Widget::New();
97922     } catch (std::out_of_range& e) {
97923       {
97924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97925       };
97926     } catch (std::exception& e) {
97927       {
97928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97929       };
97930     } catch (...) {
97931       {
97932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97933       };
97934     }
97935   }
97936   jresult = new Dali::Widget((const Dali::Widget &)result);
97937   return jresult;
97938 }
97939
97940
97941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
97942   void * jresult ;
97943   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
97944   Dali::Widget result;
97945
97946   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
97947
97948   if (!arg1) {
97949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
97950     return 0;
97951   }
97952   {
97953     try {
97954       jresult = new Dali::Widget(arg1);
97955     } catch (std::out_of_range& e) {
97956       {
97957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97958       };
97959     } catch (std::exception& e) {
97960       {
97961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97962       };
97963     } catch (...) {
97964       {
97965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97966       };
97967     }
97968   }
97969   return jresult;
97970 }
97971
97972
97973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
97974   void * jresult ;
97975   Dali::Widget *result = 0 ;
97976
97977   {
97978     try {
97979       result = (Dali::Widget *)new Dali::Widget();
97980     } catch (std::out_of_range& e) {
97981       {
97982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97983       };
97984     } catch (std::exception& e) {
97985       {
97986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97987       };
97988     } catch (...) {
97989       {
97990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97991       };
97992     }
97993   }
97994   jresult = (void *)result;
97995   return jresult;
97996 }
97997
97998
97999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
98000   void * jresult ;
98001   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
98002   Dali::Widget *arg2 = 0 ;
98003   Dali::Widget *result = 0 ;
98004
98005   arg1 = (Dali::Widget *)jarg1;
98006   arg2 = (Dali::Widget *)jarg2;
98007   if (!arg2) {
98008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
98009     return 0;
98010   }
98011   {
98012     try {
98013       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
98014     } catch (std::out_of_range& e) {
98015       {
98016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98017       };
98018     } catch (std::exception& e) {
98019       {
98020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98021       };
98022     } catch (...) {
98023       {
98024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98025       };
98026     }
98027   }
98028   jresult = (void *)result;
98029   return jresult;
98030 }
98031
98032
98033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
98034   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
98035
98036   arg1 = (Dali::Widget *)jarg1;
98037   {
98038     try {
98039       delete arg1;
98040     } catch (std::out_of_range& e) {
98041       {
98042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98043       };
98044     } catch (std::exception& e) {
98045       {
98046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98047       };
98048     } catch (...) {
98049       {
98050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98051       };
98052     }
98053   }
98054 }
98055
98056
98057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
98058   void * jresult ;
98059   SwigDirector_WidgetImpl* result;
98060   {
98061     try {
98062       result = new SwigDirector_WidgetImpl();
98063     } catch (std::out_of_range& e) {
98064       {
98065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98066       };
98067     } catch (std::exception& e) {
98068       {
98069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98070       };
98071     } catch (...) {
98072       {
98073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98074       };
98075     }
98076   }
98077   jresult = result;
98078   return jresult;
98079 }
98080
98081
98082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
98083   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98084   std::string *arg2 = 0 ;
98085   Dali::Window arg3 ;
98086   Dali::Window *argp3 ;
98087
98088   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98089   if (!jarg2) {
98090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98091     return ;
98092   }
98093   std::string arg2_str(jarg2);
98094   arg2 = &arg2_str;
98095   argp3 = (Dali::Window *)jarg3;
98096   if (!argp3) {
98097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
98098     return ;
98099   }
98100   arg3 = *argp3;
98101   {
98102     try {
98103       (arg1)->OnCreate((std::string const &)*arg2,arg3);
98104     } catch (std::out_of_range& e) {
98105       {
98106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98107       };
98108     } catch (std::exception& e) {
98109       {
98110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98111       };
98112     } catch (...) {
98113       {
98114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98115       };
98116     }
98117   }
98118 }
98119
98120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
98121   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98122   std::string *arg2 = 0 ;
98123   Dali::Window arg3 ;
98124   Dali::Window *argp3 ;
98125
98126   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98127   if (!jarg2) {
98128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98129     return ;
98130   }
98131   std::string arg2_str(jarg2);
98132   arg2 = &arg2_str;
98133   argp3 = (Dali::Window *)jarg3;
98134   if (!argp3) {
98135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
98136     return ;
98137   }
98138   arg3 = *argp3;
98139   {
98140     try {
98141       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
98142     } catch (std::out_of_range& e) {
98143       {
98144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98145       };
98146     } catch (std::exception& e) {
98147       {
98148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98149       };
98150     } catch (...) {
98151       {
98152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98153       };
98154     }
98155   }
98156 }
98157
98158
98159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
98160   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98161   std::string *arg2 = 0 ;
98162   Dali::Widget::Termination arg3 ;
98163
98164   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98165   if (!jarg2) {
98166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98167     return ;
98168   }
98169   std::string arg2_str(jarg2);
98170   arg2 = &arg2_str;
98171   arg3 = (Dali::Widget::Termination)jarg3;
98172   {
98173     try {
98174       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
98175     } catch (std::out_of_range& e) {
98176       {
98177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98178       };
98179     } catch (std::exception& e) {
98180       {
98181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98182       };
98183     } catch (...) {
98184       {
98185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98186       };
98187     }
98188   }
98189 }
98190
98191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
98192   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98193   std::string *arg2 = 0 ;
98194   Dali::Widget::Termination arg3 ;
98195
98196   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98197   if (!jarg2) {
98198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98199     return ;
98200   }
98201   std::string arg2_str(jarg2);
98202   arg2 = &arg2_str;
98203   arg3 = (Dali::Widget::Termination)jarg3;
98204   {
98205     try {
98206       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
98207     } catch (std::out_of_range& e) {
98208       {
98209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98210       };
98211     } catch (std::exception& e) {
98212       {
98213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98214       };
98215     } catch (...) {
98216       {
98217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98218       };
98219     }
98220   }
98221 }
98222
98223
98224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
98225   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98226
98227   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98228   {
98229     try {
98230       (arg1)->OnPause();
98231     } catch (std::out_of_range& e) {
98232       {
98233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98234       };
98235     } catch (std::exception& e) {
98236       {
98237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98238       };
98239     } catch (...) {
98240       {
98241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98242       };
98243     }
98244   }
98245 }
98246
98247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
98248   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98249
98250   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98251   {
98252     try {
98253       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
98254     } catch (std::out_of_range& e) {
98255       {
98256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98257       };
98258     } catch (std::exception& e) {
98259       {
98260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98261       };
98262     } catch (...) {
98263       {
98264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98265       };
98266     }
98267   }
98268 }
98269
98270
98271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
98272   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98273
98274   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98275   {
98276     try {
98277       (arg1)->OnResume();
98278     } catch (std::out_of_range& e) {
98279       {
98280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98281       };
98282     } catch (std::exception& e) {
98283       {
98284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98285       };
98286     } catch (...) {
98287       {
98288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98289       };
98290     }
98291   }
98292 }
98293
98294
98295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
98296   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98297
98298   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98299   {
98300     try {
98301       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
98302     } catch (std::out_of_range& e) {
98303       {
98304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98305       };
98306     } catch (std::exception& e) {
98307       {
98308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98309       };
98310     } catch (...) {
98311       {
98312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98313       };
98314     }
98315   }
98316 }
98317
98318
98319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
98320   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98321   Dali::Window arg2 ;
98322   Dali::Window *argp2 ;
98323
98324   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98325   argp2 = (Dali::Window *)jarg2;
98326   if (!argp2) {
98327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
98328     return ;
98329   }
98330   arg2 = *argp2;
98331   {
98332     try {
98333       (arg1)->OnResize(arg2);
98334     } catch (std::out_of_range& e) {
98335       {
98336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98337       };
98338     } catch (std::exception& e) {
98339       {
98340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98341       };
98342     } catch (...) {
98343       {
98344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98345       };
98346     }
98347   }
98348 }
98349
98350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
98351   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98352   Dali::Window arg2 ;
98353   Dali::Window *argp2 ;
98354
98355   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98356   argp2 = (Dali::Window *)jarg2;
98357   if (!argp2) {
98358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
98359     return ;
98360   }
98361   arg2 = *argp2;
98362   {
98363     try {
98364       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
98365     } catch (std::out_of_range& e) {
98366       {
98367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98368       };
98369     } catch (std::exception& e) {
98370       {
98371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98372       };
98373     } catch (...) {
98374       {
98375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98376       };
98377     }
98378   }
98379 }
98380
98381
98382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
98383   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98384   std::string *arg2 = 0 ;
98385   int arg3 ;
98386
98387   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98388   if (!jarg2) {
98389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98390     return ;
98391   }
98392   std::string arg2_str(jarg2);
98393   arg2 = &arg2_str;
98394   arg3 = (int)jarg3;
98395   {
98396     try {
98397       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
98398     } catch (std::out_of_range& e) {
98399       {
98400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98401       };
98402     } catch (std::exception& e) {
98403       {
98404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98405       };
98406     } catch (...) {
98407       {
98408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98409       };
98410     }
98411   }
98412 }
98413
98414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
98415   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98416   std::string *arg2 = 0 ;
98417   int arg3 ;
98418
98419   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98420   if (!jarg2) {
98421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98422     return ;
98423   }
98424   std::string arg2_str(jarg2);
98425   arg2 = &arg2_str;
98426   arg3 = (int)jarg3;
98427   {
98428     try {
98429       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
98430     } catch (std::out_of_range& e) {
98431       {
98432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98433       };
98434     } catch (std::exception& e) {
98435       {
98436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98437       };
98438     } catch (...) {
98439       {
98440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98441       };
98442     }
98443   }
98444 }
98445
98446
98447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
98448   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98449   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
98450   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
98451
98452   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98453   arg2 = (Dali::SlotObserver *)jarg2;
98454   arg3 = (Dali::CallbackBase *)jarg3;
98455   {
98456     try {
98457       (arg1)->SignalConnected(arg2,arg3);
98458     } catch (std::out_of_range& e) {
98459       {
98460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98461       };
98462     } catch (std::exception& e) {
98463       {
98464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98465       };
98466     } catch (...) {
98467       {
98468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98469       };
98470     }
98471   }
98472 }
98473
98474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
98475   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98476   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
98477   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
98478
98479   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98480   arg2 = (Dali::SlotObserver *)jarg2;
98481   arg3 = (Dali::CallbackBase *)jarg3;
98482   {
98483     try {
98484       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
98485     } catch (std::out_of_range& e) {
98486       {
98487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98488       };
98489     } catch (std::exception& e) {
98490       {
98491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98492       };
98493     } catch (...) {
98494       {
98495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98496       };
98497     }
98498   }
98499 }
98500
98501
98502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
98503   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98504   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
98505   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
98506
98507   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98508   arg2 = (Dali::SlotObserver *)jarg2;
98509   arg3 = (Dali::CallbackBase *)jarg3;
98510   {
98511     try {
98512       (arg1)->SignalDisconnected(arg2,arg3);
98513     } catch (std::out_of_range& e) {
98514       {
98515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98516       };
98517     } catch (std::exception& e) {
98518       {
98519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98520       };
98521     } catch (...) {
98522       {
98523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98524       };
98525     }
98526   }
98527 }
98528
98529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
98530   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98531   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
98532   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
98533
98534   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98535   arg2 = (Dali::SlotObserver *)jarg2;
98536   arg3 = (Dali::CallbackBase *)jarg3;
98537   {
98538     try {
98539       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
98540     } catch (std::out_of_range& e) {
98541       {
98542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98543       };
98544     } catch (std::exception& e) {
98545       {
98546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98547       };
98548     } catch (...) {
98549       {
98550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98551       };
98552     }
98553   }
98554 }
98555
98556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
98557   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98558   std::string *arg2 = 0 ;
98559
98560   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98561   if (!jarg2) {
98562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98563     return ;
98564   }
98565   std::string arg2_str(jarg2);
98566   arg2 = &arg2_str;
98567   {
98568     try {
98569       (arg1)->SetContentInfo((std::string const &)*arg2);
98570     } catch (std::out_of_range& e) {
98571       {
98572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98573       };
98574     } catch (std::exception& e) {
98575       {
98576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98577       };
98578     } catch (...) {
98579       {
98580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98581       };
98582     }
98583   }
98584 }
98585
98586
98587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
98588   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98589   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
98590
98591   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98592   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
98593   {
98594     try {
98595       (arg1)->SetImpl(arg2);
98596     } catch (std::out_of_range& e) {
98597       {
98598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98599       };
98600     } catch (std::exception& e) {
98601       {
98602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98603       };
98604     } catch (...) {
98605       {
98606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98607       };
98608     }
98609   }
98610 }
98611
98612 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) {
98613
98614   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
98615   if (director) {
98616     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
98617   }
98618 }
98619
98620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
98621   void * jresult ;
98622   Dali::Widget *arg1 = 0 ;
98623   SwigDirector_WidgetImpl *result = 0 ;
98624
98625   arg1 = (Dali::Widget *)jarg1;
98626   if (!arg1) {
98627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
98628     return 0;
98629   }
98630   {
98631     try {
98632       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
98633     } catch (std::out_of_range& e) {
98634       {
98635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98636       };
98637     } catch (std::exception& e) {
98638       {
98639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98640       };
98641     } catch (...) {
98642       {
98643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98644       };
98645     }
98646   }
98647
98648   jresult = (void *)result;
98649   return jresult;
98650 }
98651
98652
98653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
98654   void * jresult ;
98655   int *arg1 = (int *) 0 ;
98656   char ***arg2 ;
98657   std::string *arg3 = 0 ;
98658   Dali::WidgetApplication result;
98659   {
98660     int index = 0;
98661     int length = 0;
98662     char *retPtr;
98663     char *nextPtr;
98664     argWidgetC = jarg1;
98665     argWidgetV = new char*[jarg1 + 1];
98666
98667     retPtr = strtok_r( jarg2, " ", &nextPtr);
98668     if( retPtr )
98669     {
98670       length = strlen(retPtr);
98671     }
98672     argWidgetV[index] = new char[length + 1];
98673     if( retPtr )
98674     {
98675       strncpy(argWidgetV[index], retPtr, length);
98676     }
98677     argWidgetV[index][length] = '\0';
98678     index++;
98679
98680     while (index < jarg1)
98681     {
98682       length = 0;
98683       retPtr = strtok_r(NULL, " ", &nextPtr);
98684       if( retPtr )
98685       {
98686         length = strlen(retPtr);
98687       }
98688       argWidgetV[index] = new char[length + 1];
98689       if( retPtr )
98690       {
98691         strncpy(argWidgetV[index], retPtr, length);
98692       }
98693       argWidgetV[index][length] = '\0';
98694       index++;
98695     }
98696
98697     argWidgetV[jarg1] = NULL;
98698     argWidgetC = jarg1;
98699
98700     arg1 = &argWidgetC;
98701     arg2 = &argWidgetV;
98702   }
98703
98704   if (!jarg3) {
98705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98706     return 0;
98707   }
98708   std::string arg3_str(jarg3);
98709   arg3 = &arg3_str;
98710   {
98711     try {
98712       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
98713     } catch (std::out_of_range& e) {
98714       {
98715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98716       };
98717     } catch (std::exception& e) {
98718       {
98719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98720       };
98721     } catch (...) {
98722       {
98723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98724       };
98725     }
98726   }
98727   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
98728
98729   return jresult;
98730 }
98731
98732
98733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
98734   void * jresult ;
98735   Dali::WidgetApplication *result = 0 ;
98736
98737   {
98738     try {
98739       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
98740     } catch (std::out_of_range& e) {
98741       {
98742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98743       };
98744     } catch (std::exception& e) {
98745       {
98746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98747       };
98748     } catch (...) {
98749       {
98750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98751       };
98752     }
98753   }
98754   jresult = (void *)result;
98755   return jresult;
98756 }
98757
98758
98759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
98760   void * jresult ;
98761   Dali::WidgetApplication *arg1 = 0 ;
98762   Dali::WidgetApplication *result = 0 ;
98763
98764   arg1 = (Dali::WidgetApplication *)jarg1;
98765   if (!arg1) {
98766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
98767     return 0;
98768   }
98769   {
98770     try {
98771       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
98772     } catch (std::out_of_range& e) {
98773       {
98774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98775       };
98776     } catch (std::exception& e) {
98777       {
98778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98779       };
98780     } catch (...) {
98781       {
98782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98783       };
98784     }
98785   }
98786   jresult = (void *)result;
98787   return jresult;
98788 }
98789
98790
98791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
98792   void * jresult ;
98793   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
98794   Dali::WidgetApplication *arg2 = 0 ;
98795   Dali::WidgetApplication *result = 0 ;
98796
98797   arg1 = (Dali::WidgetApplication *)jarg1;
98798   arg2 = (Dali::WidgetApplication *)jarg2;
98799   if (!arg2) {
98800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
98801     return 0;
98802   }
98803   {
98804     try {
98805       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
98806     } catch (std::out_of_range& e) {
98807       {
98808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98809       };
98810     } catch (std::exception& e) {
98811       {
98812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98813       };
98814     } catch (...) {
98815       {
98816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98817       };
98818     }
98819   }
98820   jresult = (void *)result;
98821   return jresult;
98822 }
98823
98824
98825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
98826   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
98827
98828   arg1 = (Dali::WidgetApplication *)jarg1;
98829   {
98830     try {
98831       delete arg1;
98832       if( argWidgetV )
98833       {
98834         // free string data
98835         for( int i=0; i < argWidgetC+1; i++)
98836         {
98837           delete [] argWidgetV[i];
98838         }
98839         delete [] argWidgetV;
98840       }
98841     } catch (std::out_of_range& e) {
98842       {
98843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98844       };
98845     } catch (std::exception& e) {
98846       {
98847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98848       };
98849     } catch (...) {
98850       {
98851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98852       };
98853     }
98854   }
98855 }
98856
98857
98858 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
98859 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
98860
98861 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
98862 {
98863   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
98864   return *widget;
98865 }
98866
98867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
98868   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
98869   std::string *arg2 = 0 ;
98870
98871   arg1 = (Dali::WidgetApplication *)jarg1;
98872   if (!jarg2) {
98873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98874     return ;
98875   }
98876   std::string arg2_str(*jarg2);
98877   arg2 = &arg2_str;
98878
98879   if(!_CSharpCreateWidgetFunction)
98880   {
98881     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
98882   }
98883
98884   {
98885     try {
98886       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
98887     } catch (std::out_of_range& e) {
98888       {
98889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98890       };
98891     } catch (std::exception& e) {
98892       {
98893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98894       };
98895     } catch (...) {
98896       {
98897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98898       };
98899     }
98900   }
98901
98902   //Typemap argout in c++ file.
98903   //This will convert c++ string to c# string
98904   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
98905 }
98906
98907
98908 //for PixelBuffer and ImageLoading
98909
98910 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
98911     return (Dali::BaseHandle *)jarg1;
98912 }
98913
98914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
98915   void * jresult ;
98916   unsigned int arg1 ;
98917   unsigned int arg2 ;
98918   Dali::Pixel::Format arg3 ;
98919   Dali::Devel::PixelBuffer result;
98920
98921   arg1 = (unsigned int)jarg1;
98922   arg2 = (unsigned int)jarg2;
98923   arg3 = (Dali::Pixel::Format)jarg3;
98924   {
98925     try {
98926       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
98927     } catch (std::out_of_range& e) {
98928       {
98929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98930       };
98931     } catch (std::exception& e) {
98932       {
98933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98934       };
98935     } catch (...) {
98936       {
98937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98938       };
98939     }
98940   }
98941   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98942   return jresult;
98943 }
98944
98945
98946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
98947   void * jresult ;
98948   Dali::Devel::PixelBuffer *result = 0 ;
98949
98950   {
98951     try {
98952       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
98953     } catch (std::out_of_range& e) {
98954       {
98955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98956       };
98957     } catch (std::exception& e) {
98958       {
98959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98960       };
98961     } catch (...) {
98962       {
98963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98964       };
98965     }
98966   }
98967   jresult = (void *)result;
98968   return jresult;
98969 }
98970
98971
98972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
98973   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
98974
98975   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
98976   {
98977     try {
98978       delete arg1;
98979     } catch (std::out_of_range& e) {
98980       {
98981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98982       };
98983     } catch (std::exception& e) {
98984       {
98985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98986       };
98987     } catch (...) {
98988       {
98989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98990       };
98991     }
98992   }
98993 }
98994
98995
98996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
98997   void * jresult ;
98998   Dali::Devel::PixelBuffer *arg1 = 0 ;
98999   Dali::Devel::PixelBuffer *result = 0 ;
99000
99001   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99002   if (!arg1) {
99003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
99004     return 0;
99005   }
99006   {
99007     try {
99008       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
99009     } catch (std::out_of_range& e) {
99010       {
99011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99012       };
99013     } catch (std::exception& e) {
99014       {
99015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99016       };
99017     } catch (...) {
99018       {
99019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99020       };
99021     }
99022   }
99023   jresult = (void *)result;
99024   return jresult;
99025 }
99026
99027
99028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
99029   void * jresult ;
99030   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99031   Dali::Devel::PixelBuffer *arg2 = 0 ;
99032   Dali::Devel::PixelBuffer *result = 0 ;
99033
99034   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99035   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
99036   if (!arg2) {
99037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
99038     return 0;
99039   }
99040   {
99041     try {
99042       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
99043     } catch (std::out_of_range& e) {
99044       {
99045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99046       };
99047     } catch (std::exception& e) {
99048       {
99049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99050       };
99051     } catch (...) {
99052       {
99053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99054       };
99055     }
99056   }
99057   jresult = (void *)result;
99058   return jresult;
99059 }
99060
99061
99062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
99063   void * jresult ;
99064   Dali::Devel::PixelBuffer *arg1 = 0 ;
99065   Dali::PixelData result;
99066
99067   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99068   if (!arg1) {
99069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
99070     return 0;
99071   }
99072   {
99073     try {
99074       result = Dali::Devel::PixelBuffer::Convert(*arg1);
99075     } catch (std::out_of_range& e) {
99076       {
99077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99078       };
99079     } catch (std::exception& e) {
99080       {
99081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99082       };
99083     } catch (...) {
99084       {
99085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99086       };
99087     }
99088   }
99089   jresult = new Dali::PixelData((const Dali::PixelData &)result);
99090   return jresult;
99091 }
99092
99093
99094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
99095   void * jresult ;
99096   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99097   Dali::PixelData result;
99098
99099   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99100   {
99101     try {
99102       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
99103     } catch (std::out_of_range& e) {
99104       {
99105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99106       };
99107     } catch (std::exception& e) {
99108       {
99109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99110       };
99111     } catch (...) {
99112       {
99113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99114       };
99115     }
99116   }
99117   jresult = new Dali::PixelData((const Dali::PixelData &)result);
99118   return jresult;
99119 }
99120
99121
99122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
99123   void * jresult ;
99124   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99125   unsigned char *result = 0 ;
99126
99127   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99128   {
99129     try {
99130       result = (unsigned char *)(arg1)->GetBuffer();
99131     } catch (std::out_of_range& e) {
99132       {
99133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99134       };
99135     } catch (std::exception& e) {
99136       {
99137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99138       };
99139     } catch (...) {
99140       {
99141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99142       };
99143     }
99144   }
99145   jresult = (void *)result;
99146   return jresult;
99147 }
99148
99149
99150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
99151   unsigned int jresult ;
99152   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99153   unsigned int result;
99154
99155   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99156   {
99157     try {
99158       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
99159     } catch (std::out_of_range& e) {
99160       {
99161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99162       };
99163     } catch (std::exception& e) {
99164       {
99165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99166       };
99167     } catch (...) {
99168       {
99169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99170       };
99171     }
99172   }
99173   jresult = result;
99174   return jresult;
99175 }
99176
99177
99178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
99179   unsigned int jresult ;
99180   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99181   unsigned int result;
99182
99183   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99184   {
99185     try {
99186       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
99187     } catch (std::out_of_range& e) {
99188       {
99189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99190       };
99191     } catch (std::exception& e) {
99192       {
99193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99194       };
99195     } catch (...) {
99196       {
99197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99198       };
99199     }
99200   }
99201   jresult = result;
99202   return jresult;
99203 }
99204
99205
99206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
99207   int jresult ;
99208   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99209   Dali::Pixel::Format result;
99210
99211   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99212   {
99213     try {
99214       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
99215     } catch (std::out_of_range& e) {
99216       {
99217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99218       };
99219     } catch (std::exception& e) {
99220       {
99221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99222       };
99223     } catch (...) {
99224       {
99225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99226       };
99227     }
99228   }
99229   jresult = (int)result;
99230   return jresult;
99231 }
99232
99233
99234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
99235   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99236   Dali::Devel::PixelBuffer arg2 ;
99237   float arg3 ;
99238   bool arg4 ;
99239   Dali::Devel::PixelBuffer *argp2 ;
99240
99241   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99242   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
99243   if (!argp2) {
99244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
99245     return ;
99246   }
99247   arg2 = *argp2;
99248   arg3 = (float)jarg3;
99249   arg4 = jarg4 ? true : false;
99250   {
99251     try {
99252       (arg1)->ApplyMask(arg2,arg3,arg4);
99253     } catch (std::out_of_range& e) {
99254       {
99255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99256       };
99257     } catch (std::exception& e) {
99258       {
99259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99260       };
99261     } catch (...) {
99262       {
99263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99264       };
99265     }
99266   }
99267 }
99268
99269
99270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
99271   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99272   Dali::Devel::PixelBuffer arg2 ;
99273   float arg3 ;
99274   Dali::Devel::PixelBuffer *argp2 ;
99275
99276   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99277   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
99278   if (!argp2) {
99279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
99280     return ;
99281   }
99282   arg2 = *argp2;
99283   arg3 = (float)jarg3;
99284   {
99285     try {
99286       (arg1)->ApplyMask(arg2,arg3);
99287     } catch (std::out_of_range& e) {
99288       {
99289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99290       };
99291     } catch (std::exception& e) {
99292       {
99293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99294       };
99295     } catch (...) {
99296       {
99297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99298       };
99299     }
99300   }
99301 }
99302
99303
99304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
99305   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99306   Dali::Devel::PixelBuffer arg2 ;
99307   Dali::Devel::PixelBuffer *argp2 ;
99308
99309   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99310   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
99311   if (!argp2) {
99312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
99313     return ;
99314   }
99315   arg2 = *argp2;
99316   {
99317     try {
99318       (arg1)->ApplyMask(arg2);
99319     } catch (std::out_of_range& e) {
99320       {
99321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99322       };
99323     } catch (std::exception& e) {
99324       {
99325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99326       };
99327     } catch (...) {
99328       {
99329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99330       };
99331     }
99332   }
99333 }
99334
99335
99336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
99337   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99338   float arg2 ;
99339
99340   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99341   arg2 = (float)jarg2;
99342   {
99343     try {
99344       (arg1)->ApplyGaussianBlur(arg2);
99345     } catch (std::out_of_range& e) {
99346       {
99347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99348       };
99349     } catch (std::exception& e) {
99350       {
99351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99352       };
99353     } catch (...) {
99354       {
99355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99356       };
99357     }
99358   }
99359 }
99360
99361
99362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
99363   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99364   uint16_t arg2 ;
99365   uint16_t arg3 ;
99366   uint16_t arg4 ;
99367   uint16_t arg5 ;
99368
99369   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99370   arg2 = (uint16_t)jarg2;
99371   arg3 = (uint16_t)jarg3;
99372   arg4 = (uint16_t)jarg4;
99373   arg5 = (uint16_t)jarg5;
99374   {
99375     try {
99376       (arg1)->Crop(arg2,arg3,arg4,arg5);
99377     } catch (std::out_of_range& e) {
99378       {
99379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99380       };
99381     } catch (std::exception& e) {
99382       {
99383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99384       };
99385     } catch (...) {
99386       {
99387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99388       };
99389     }
99390   }
99391 }
99392
99393
99394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
99395   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99396   uint16_t arg2 ;
99397   uint16_t arg3 ;
99398
99399   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99400   arg2 = (uint16_t)jarg2;
99401   arg3 = (uint16_t)jarg3;
99402   {
99403     try {
99404       (arg1)->Resize(arg2,arg3);
99405     } catch (std::out_of_range& e) {
99406       {
99407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99408       };
99409     } catch (std::exception& e) {
99410       {
99411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99412       };
99413     } catch (...) {
99414       {
99415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99416       };
99417     }
99418   }
99419 }
99420
99421 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
99422   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99423   Dali::Degree * arg2 ;
99424
99425   bool result = false;
99426
99427   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99428   arg2 = (Dali::Degree *)jarg2;
99429   {
99430     try {
99431       result = (arg1)->Rotate(*arg2);
99432     } catch (std::out_of_range& e) {
99433       {
99434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
99435       };
99436     } catch (std::exception& e) {
99437       {
99438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
99439       };
99440     } catch (...) {
99441       {
99442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
99443       };
99444     }
99445   }
99446   return result;
99447 }
99448
99449
99450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
99451   void * jresult ;
99452   std::string *arg1 = 0 ;
99453   Dali::ImageDimensions arg2 ;
99454   Dali::FittingMode::Type arg3 ;
99455   Dali::SamplingMode::Type arg4 ;
99456   bool arg5 ;
99457   Dali::ImageDimensions *argp2 ;
99458   Dali::Devel::PixelBuffer result;
99459
99460   if (!jarg1) {
99461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99462     return 0;
99463   }
99464   std::string arg1_str(jarg1);
99465   arg1 = &arg1_str;
99466   argp2 = (Dali::ImageDimensions *)jarg2;
99467   if (!argp2) {
99468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99469     return 0;
99470   }
99471   arg2 = *argp2;
99472   arg3 = (Dali::FittingMode::Type)jarg3;
99473   arg4 = (Dali::SamplingMode::Type)jarg4;
99474   arg5 = jarg5 ? true : false;
99475   {
99476     try {
99477       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
99478     } catch (std::out_of_range& e) {
99479       {
99480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99481       };
99482     } catch (std::exception& e) {
99483       {
99484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99485       };
99486     } catch (...) {
99487       {
99488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99489       };
99490     }
99491   }
99492   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99493
99494   return jresult;
99495 }
99496
99497
99498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
99499   void * jresult ;
99500   std::string *arg1 = 0 ;
99501   Dali::ImageDimensions arg2 ;
99502   Dali::FittingMode::Type arg3 ;
99503   Dali::SamplingMode::Type arg4 ;
99504   Dali::ImageDimensions *argp2 ;
99505   Dali::Devel::PixelBuffer result;
99506
99507   if (!jarg1) {
99508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99509     return 0;
99510   }
99511   std::string arg1_str(jarg1);
99512   arg1 = &arg1_str;
99513   argp2 = (Dali::ImageDimensions *)jarg2;
99514   if (!argp2) {
99515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99516     return 0;
99517   }
99518   arg2 = *argp2;
99519   arg3 = (Dali::FittingMode::Type)jarg3;
99520   arg4 = (Dali::SamplingMode::Type)jarg4;
99521   {
99522     try {
99523       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
99524     } catch (std::out_of_range& e) {
99525       {
99526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99527       };
99528     } catch (std::exception& e) {
99529       {
99530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99531       };
99532     } catch (...) {
99533       {
99534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99535       };
99536     }
99537   }
99538   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99539
99540   return jresult;
99541 }
99542
99543
99544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
99545   void * jresult ;
99546   std::string *arg1 = 0 ;
99547   Dali::ImageDimensions arg2 ;
99548   Dali::FittingMode::Type arg3 ;
99549   Dali::ImageDimensions *argp2 ;
99550   Dali::Devel::PixelBuffer result;
99551
99552   if (!jarg1) {
99553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99554     return 0;
99555   }
99556   std::string arg1_str(jarg1);
99557   arg1 = &arg1_str;
99558   argp2 = (Dali::ImageDimensions *)jarg2;
99559   if (!argp2) {
99560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99561     return 0;
99562   }
99563   arg2 = *argp2;
99564   arg3 = (Dali::FittingMode::Type)jarg3;
99565   {
99566     try {
99567       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
99568     } catch (std::out_of_range& e) {
99569       {
99570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99571       };
99572     } catch (std::exception& e) {
99573       {
99574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99575       };
99576     } catch (...) {
99577       {
99578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99579       };
99580     }
99581   }
99582   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99583
99584   return jresult;
99585 }
99586
99587
99588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
99589   void * jresult ;
99590   std::string *arg1 = 0 ;
99591   Dali::ImageDimensions arg2 ;
99592   Dali::ImageDimensions *argp2 ;
99593   Dali::Devel::PixelBuffer result;
99594
99595   if (!jarg1) {
99596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99597     return 0;
99598   }
99599   std::string arg1_str(jarg1);
99600   arg1 = &arg1_str;
99601   argp2 = (Dali::ImageDimensions *)jarg2;
99602   if (!argp2) {
99603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99604     return 0;
99605   }
99606   arg2 = *argp2;
99607   {
99608     try {
99609       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
99610     } catch (std::out_of_range& e) {
99611       {
99612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99613       };
99614     } catch (std::exception& e) {
99615       {
99616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99617       };
99618     } catch (...) {
99619       {
99620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99621       };
99622     }
99623   }
99624   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99625
99626   return jresult;
99627 }
99628
99629
99630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
99631   void * jresult ;
99632   std::string *arg1 = 0 ;
99633   Dali::Devel::PixelBuffer result;
99634
99635   if (!jarg1) {
99636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99637     return 0;
99638   }
99639   std::string arg1_str(jarg1);
99640   arg1 = &arg1_str;
99641   {
99642     try {
99643       result = Dali::LoadImageFromFile((std::string const &)*arg1);
99644     } catch (std::out_of_range& e) {
99645       {
99646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99647       };
99648     } catch (std::exception& e) {
99649       {
99650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99651       };
99652     } catch (...) {
99653       {
99654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99655       };
99656     }
99657   }
99658   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99659
99660   return jresult;
99661 }
99662
99663
99664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
99665   void * jresult ;
99666   std::string *arg1 = 0 ;
99667   Dali::ImageDimensions arg2 ;
99668   Dali::FittingMode::Type arg3 ;
99669   Dali::SamplingMode::Type arg4 ;
99670   bool arg5 ;
99671   Dali::ImageDimensions *argp2 ;
99672   Dali::ImageDimensions result;
99673
99674   if (!jarg1) {
99675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99676     return 0;
99677   }
99678   std::string arg1_str(jarg1);
99679   arg1 = &arg1_str;
99680   argp2 = (Dali::ImageDimensions *)jarg2;
99681   if (!argp2) {
99682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99683     return 0;
99684   }
99685   arg2 = *argp2;
99686   arg3 = (Dali::FittingMode::Type)jarg3;
99687   arg4 = (Dali::SamplingMode::Type)jarg4;
99688   arg5 = jarg5 ? true : false;
99689   {
99690     try {
99691       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
99692     } catch (std::out_of_range& e) {
99693       {
99694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99695       };
99696     } catch (std::exception& e) {
99697       {
99698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99699       };
99700     } catch (...) {
99701       {
99702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99703       };
99704     }
99705   }
99706   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99707
99708   return jresult;
99709 }
99710
99711
99712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
99713   void * jresult ;
99714   std::string *arg1 = 0 ;
99715   Dali::ImageDimensions arg2 ;
99716   Dali::FittingMode::Type arg3 ;
99717   Dali::SamplingMode::Type arg4 ;
99718   Dali::ImageDimensions *argp2 ;
99719   Dali::ImageDimensions result;
99720
99721   if (!jarg1) {
99722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99723     return 0;
99724   }
99725   std::string arg1_str(jarg1);
99726   arg1 = &arg1_str;
99727   argp2 = (Dali::ImageDimensions *)jarg2;
99728   if (!argp2) {
99729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99730     return 0;
99731   }
99732   arg2 = *argp2;
99733   arg3 = (Dali::FittingMode::Type)jarg3;
99734   arg4 = (Dali::SamplingMode::Type)jarg4;
99735   {
99736     try {
99737       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
99738     } catch (std::out_of_range& e) {
99739       {
99740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99741       };
99742     } catch (std::exception& e) {
99743       {
99744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99745       };
99746     } catch (...) {
99747       {
99748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99749       };
99750     }
99751   }
99752   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99753
99754   return jresult;
99755 }
99756
99757
99758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
99759   void * jresult ;
99760   std::string *arg1 = 0 ;
99761   Dali::ImageDimensions arg2 ;
99762   Dali::FittingMode::Type arg3 ;
99763   Dali::ImageDimensions *argp2 ;
99764   Dali::ImageDimensions result;
99765
99766   if (!jarg1) {
99767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99768     return 0;
99769   }
99770   std::string arg1_str(jarg1);
99771   arg1 = &arg1_str;
99772   argp2 = (Dali::ImageDimensions *)jarg2;
99773   if (!argp2) {
99774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99775     return 0;
99776   }
99777   arg2 = *argp2;
99778   arg3 = (Dali::FittingMode::Type)jarg3;
99779   {
99780     try {
99781       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
99782     } catch (std::out_of_range& e) {
99783       {
99784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99785       };
99786     } catch (std::exception& e) {
99787       {
99788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99789       };
99790     } catch (...) {
99791       {
99792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99793       };
99794     }
99795   }
99796   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99797
99798   return jresult;
99799 }
99800
99801
99802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
99803   void * jresult ;
99804   std::string *arg1 = 0 ;
99805   Dali::ImageDimensions arg2 ;
99806   Dali::ImageDimensions *argp2 ;
99807   Dali::ImageDimensions result;
99808
99809   if (!jarg1) {
99810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99811     return 0;
99812   }
99813   std::string arg1_str(jarg1);
99814   arg1 = &arg1_str;
99815   argp2 = (Dali::ImageDimensions *)jarg2;
99816   if (!argp2) {
99817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99818     return 0;
99819   }
99820   arg2 = *argp2;
99821   {
99822     try {
99823       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
99824     } catch (std::out_of_range& e) {
99825       {
99826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99827       };
99828     } catch (std::exception& e) {
99829       {
99830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99831       };
99832     } catch (...) {
99833       {
99834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99835       };
99836     }
99837   }
99838   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99839
99840   return jresult;
99841 }
99842
99843
99844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
99845   void * jresult ;
99846   std::string *arg1 = 0 ;
99847   Dali::ImageDimensions result;
99848
99849   if (!jarg1) {
99850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99851     return 0;
99852   }
99853   std::string arg1_str(jarg1);
99854   arg1 = &arg1_str;
99855   {
99856     try {
99857       result = Dali::GetClosestImageSize((std::string const &)*arg1);
99858     } catch (std::out_of_range& e) {
99859       {
99860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99861       };
99862     } catch (std::exception& e) {
99863       {
99864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99865       };
99866     } catch (...) {
99867       {
99868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99869       };
99870     }
99871   }
99872   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99873
99874   return jresult;
99875 }
99876
99877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
99878   void * jresult ;
99879   std::string *arg1 = 0 ;
99880   Dali::ImageDimensions result;
99881
99882   if (!jarg1) {
99883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99884     return 0;
99885   }
99886   std::string arg1_str(jarg1);
99887   arg1 = &arg1_str;
99888   {
99889     try {
99890       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
99891     } catch (std::out_of_range& e) {
99892       {
99893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99894       };
99895     } catch (std::exception& e) {
99896       {
99897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99898       };
99899     } catch (...) {
99900       {
99901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99902       };
99903     }
99904   }
99905   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
99906
99907   return jresult;
99908 }
99909
99910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
99911   void * jresult ;
99912   std::string *arg1 = 0 ;
99913   Dali::ImageDimensions arg2 ;
99914   Dali::FittingMode::Type arg3 ;
99915   Dali::SamplingMode::Type arg4 ;
99916   bool arg5 ;
99917   Dali::ImageDimensions *argp2 ;
99918   Dali::Devel::PixelBuffer result;
99919
99920   if (!jarg1) {
99921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99922     return 0;
99923   }
99924   std::string arg1_str(jarg1);
99925   arg1 = &arg1_str;
99926   argp2 = (Dali::ImageDimensions *)jarg2;
99927   if (!argp2) {
99928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99929     return 0;
99930   }
99931   arg2 = *argp2;
99932   arg3 = (Dali::FittingMode::Type)jarg3;
99933   arg4 = (Dali::SamplingMode::Type)jarg4;
99934   arg5 = jarg5 ? true : false;
99935   {
99936     try {
99937       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
99938     } catch (std::out_of_range& e) {
99939       {
99940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99941       };
99942     } catch (std::exception& e) {
99943       {
99944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99945       };
99946     } catch (...) {
99947       {
99948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99949       };
99950     }
99951   }
99952   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99953
99954   return jresult;
99955 }
99956
99957
99958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
99959   void * jresult ;
99960   std::string *arg1 = 0 ;
99961   Dali::ImageDimensions arg2 ;
99962   Dali::FittingMode::Type arg3 ;
99963   Dali::SamplingMode::Type arg4 ;
99964   Dali::ImageDimensions *argp2 ;
99965   Dali::Devel::PixelBuffer result;
99966
99967   if (!jarg1) {
99968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99969     return 0;
99970   }
99971   std::string arg1_str(jarg1);
99972   arg1 = &arg1_str;
99973   argp2 = (Dali::ImageDimensions *)jarg2;
99974   if (!argp2) {
99975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
99976     return 0;
99977   }
99978   arg2 = *argp2;
99979   arg3 = (Dali::FittingMode::Type)jarg3;
99980   arg4 = (Dali::SamplingMode::Type)jarg4;
99981   {
99982     try {
99983       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
99984     } catch (std::out_of_range& e) {
99985       {
99986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99987       };
99988     } catch (std::exception& e) {
99989       {
99990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99991       };
99992     } catch (...) {
99993       {
99994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99995       };
99996     }
99997   }
99998   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99999
100000   return jresult;
100001 }
100002
100003
100004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
100005   void * jresult ;
100006   std::string *arg1 = 0 ;
100007   Dali::ImageDimensions arg2 ;
100008   Dali::FittingMode::Type arg3 ;
100009   Dali::ImageDimensions *argp2 ;
100010   Dali::Devel::PixelBuffer result;
100011
100012   if (!jarg1) {
100013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100014     return 0;
100015   }
100016   std::string arg1_str(jarg1);
100017   arg1 = &arg1_str;
100018   argp2 = (Dali::ImageDimensions *)jarg2;
100019   if (!argp2) {
100020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100021     return 0;
100022   }
100023   arg2 = *argp2;
100024   arg3 = (Dali::FittingMode::Type)jarg3;
100025   {
100026     try {
100027       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
100028     } catch (std::out_of_range& e) {
100029       {
100030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100031       };
100032     } catch (std::exception& e) {
100033       {
100034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100035       };
100036     } catch (...) {
100037       {
100038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100039       };
100040     }
100041   }
100042   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100043
100044   return jresult;
100045 }
100046
100047
100048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
100049   void * jresult ;
100050   std::string *arg1 = 0 ;
100051   Dali::ImageDimensions arg2 ;
100052   Dali::ImageDimensions *argp2 ;
100053   Dali::Devel::PixelBuffer result;
100054
100055   if (!jarg1) {
100056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100057     return 0;
100058   }
100059   std::string arg1_str(jarg1);
100060   arg1 = &arg1_str;
100061   argp2 = (Dali::ImageDimensions *)jarg2;
100062   if (!argp2) {
100063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100064     return 0;
100065   }
100066   arg2 = *argp2;
100067   {
100068     try {
100069       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
100070     } catch (std::out_of_range& e) {
100071       {
100072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100073       };
100074     } catch (std::exception& e) {
100075       {
100076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100077       };
100078     } catch (...) {
100079       {
100080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100081       };
100082     }
100083   }
100084   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100085
100086   return jresult;
100087 }
100088
100089
100090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
100091   void * jresult ;
100092   std::string *arg1 = 0 ;
100093   Dali::Devel::PixelBuffer result;
100094
100095   if (!jarg1) {
100096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100097     return 0;
100098   }
100099   std::string arg1_str(jarg1);
100100   arg1 = &arg1_str;
100101   {
100102     try {
100103       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
100104     } catch (std::out_of_range& e) {
100105       {
100106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100107       };
100108     } catch (std::exception& e) {
100109       {
100110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100111       };
100112     } catch (...) {
100113       {
100114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100115       };
100116     }
100117   }
100118   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100119
100120   return jresult;
100121 }
100122
100123
100124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
100125   void * jresult ;
100126   Dali::Toolkit::WebView result;
100127
100128   {
100129     try {
100130       result = Dali::Toolkit::WebView::New();
100131     } catch (std::out_of_range& e) {
100132       {
100133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100134       };
100135     } catch (std::exception& e) {
100136       {
100137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100138       };
100139     } catch (Dali::DaliException e) {
100140       {
100141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100142       };
100143     } catch (...) {
100144       {
100145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100146       };
100147     }
100148   }
100149   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
100150   return jresult;
100151 }
100152
100153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
100154   void * jresult ;
100155   Dali::Toolkit::WebView result;
100156
100157   std::string *arg1;
100158   std::string *arg2;
100159
100160   if (!jarg1) {
100161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
100162     return 0;
100163   }
100164   if (!jarg2) {
100165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
100166     return 0;
100167   }
100168
100169   std::string jarg1_str = std::string(jarg1);
100170   std::string jarg2_str = std::string(jarg2);
100171
100172   arg1 = &jarg1_str;
100173   arg2 = &jarg2_str;
100174
100175   {
100176     try {
100177       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
100178     } catch (std::out_of_range& e) {
100179       {
100180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100181       };
100182     } catch (std::exception& e) {
100183       {
100184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100185       };
100186     } catch (Dali::DaliException e) {
100187       {
100188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100189       };
100190     } catch (...) {
100191       {
100192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100193       };
100194     }
100195   }
100196   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
100197   return jresult;
100198 }
100199
100200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
100201   void * jresult ;
100202   Dali::Toolkit::WebView *arg1 = 0 ;
100203   Dali::Toolkit::WebView *result = 0 ;
100204
100205   arg1 = (Dali::Toolkit::WebView *)jarg1;
100206   if (!arg1) {
100207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
100208     return 0;
100209   }
100210   {
100211     try {
100212       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
100213     } catch (std::out_of_range& e) {
100214       {
100215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100216       };
100217     } catch (std::exception& e) {
100218       {
100219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100220       };
100221     } catch (Dali::DaliException e) {
100222       {
100223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100224       };
100225     } catch (...) {
100226       {
100227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100228       };
100229     }
100230   }
100231   jresult = (void *)result;
100232   return jresult;
100233 }
100234
100235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
100236   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100237   arg1 = (Dali::Toolkit::WebView *)jarg1;
100238   {
100239     try {
100240       delete arg1;
100241     } catch (std::out_of_range& e) {
100242       {
100243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100244       };
100245     } catch (std::exception& e) {
100246       {
100247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100248       };
100249     } catch (Dali::DaliException e) {
100250       {
100251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100252       };
100253     } catch (...) {
100254       {
100255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100256       };
100257     }
100258   }
100259 }
100260
100261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
100262   void * jresult ;
100263   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100264   Dali::Toolkit::WebView *arg2 = 0 ;
100265   Dali::Toolkit::WebView *result = 0 ;
100266
100267   arg1 = (Dali::Toolkit::WebView *)jarg1;
100268   arg2 = (Dali::Toolkit::WebView *)jarg2;
100269   if (!arg2) {
100270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
100271     return 0;
100272   }
100273   {
100274     try {
100275       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
100276     } catch (std::out_of_range& e) {
100277       {
100278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100279       };
100280     } catch (std::exception& e) {
100281       {
100282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100283       };
100284     } catch (Dali::DaliException e) {
100285       {
100286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100287       };
100288     } catch (...) {
100289       {
100290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100291       };
100292     }
100293   }
100294   jresult = (void *)result;
100295   return jresult;
100296 }
100297
100298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
100299   void * jresult ;
100300   Dali::BaseHandle arg1 ;
100301   Dali::BaseHandle *argp1 ;
100302   Dali::Toolkit::WebView result;
100303
100304   argp1 = (Dali::BaseHandle *)jarg1;
100305   if (!argp1) {
100306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
100307     return 0;
100308   }
100309   arg1 = *argp1;
100310   {
100311     try {
100312       result = Dali::Toolkit::WebView::DownCast(arg1);
100313     } catch (std::out_of_range& e) {
100314       {
100315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100316       };
100317     } catch (std::exception& e) {
100318       {
100319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100320       };
100321     } catch (Dali::DaliException e) {
100322       {
100323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100324       };
100325     } catch (...) {
100326       {
100327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100328       };
100329     }
100330   }
100331   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
100332   return jresult;
100333 }
100334
100335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
100336   return (int) Dali::Toolkit::WebView::Property::URL;
100337 }
100338
100339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
100340   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
100341 }
100342
100343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
100344   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
100345 }
100346
100347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
100348   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
100349 }
100350
100351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
100352   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
100353 }
100354
100355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
100356   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
100357 }
100358
100359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
100360   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
100361 }
100362
100363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
100364   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
100365 }
100366
100367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
100368   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100369   std::string *arg2;
100370
100371   arg1 = (Dali::Toolkit::WebView *)jarg1;
100372
100373   if (!jarg2) {
100374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100375     return;
100376   }
100377
100378   std::string jarg2str = std::string(jarg2);
100379   arg2 = &jarg2str;
100380   {
100381     try {
100382       (arg1)->LoadUrl((std::string const &)*arg2);
100383     } catch (std::out_of_range& e) {
100384       {
100385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100386       };
100387     } catch (std::exception& e) {
100388       {
100389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100390       };
100391     } catch (Dali::DaliException e) {
100392       {
100393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100394       };
100395     } catch (...) {
100396       {
100397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100398       };
100399     }
100400   }
100401 }
100402
100403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
100404   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100405   std::string *arg2;
100406
100407   arg1 = (Dali::Toolkit::WebView *)jarg1;
100408   if (!jarg2) {
100409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100410     return;
100411   }
100412   std::string jarg2str = std::string(jarg2);
100413   arg2 = &jarg2str;
100414   {
100415     try {
100416       (arg1)->LoadHTMLString((std::string const &)*arg2);
100417     } catch (std::out_of_range& e) {
100418       {
100419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100420       };
100421     } catch (std::exception& e) {
100422       {
100423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100424       };
100425     } catch (Dali::DaliException e) {
100426       {
100427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100428       };
100429     } catch (...) {
100430       {
100431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100432       };
100433     }
100434   }
100435 }
100436
100437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
100438   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100439
100440   arg1 = (Dali::Toolkit::WebView *)jarg1;
100441   {
100442     try {
100443       (arg1)->Reload();
100444     } catch (std::out_of_range& e) {
100445       {
100446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100447       };
100448     } catch (std::exception& e) {
100449       {
100450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100451       };
100452     } catch (Dali::DaliException e) {
100453       {
100454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100455       };
100456     } catch (...) {
100457       {
100458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100459       };
100460     }
100461   }
100462 }
100463
100464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
100465   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100466
100467   arg1 = (Dali::Toolkit::WebView *)jarg1;
100468   {
100469     try {
100470       (arg1)->StopLoading();
100471     } catch (std::out_of_range& e) {
100472       {
100473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100474       };
100475     } catch (std::exception& e) {
100476       {
100477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100478       };
100479     } catch (Dali::DaliException e) {
100480       {
100481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100482       };
100483     } catch (...) {
100484       {
100485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100486       };
100487     }
100488   }
100489 }
100490
100491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
100492   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100493
100494   arg1 = (Dali::Toolkit::WebView *)jarg1;
100495   {
100496     try {
100497       (arg1)->Suspend();
100498     } catch (std::out_of_range& e) {
100499       {
100500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100501       };
100502     } catch (std::exception& e) {
100503       {
100504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100505       };
100506     } catch (Dali::DaliException e) {
100507       {
100508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100509       };
100510     } catch (...) {
100511       {
100512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100513       };
100514     }
100515   }
100516 }
100517
100518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
100519   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100520
100521   arg1 = (Dali::Toolkit::WebView *)jarg1;
100522   {
100523     try {
100524       (arg1)->Resume();
100525     } catch (std::out_of_range& e) {
100526       {
100527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100528       };
100529     } catch (std::exception& e) {
100530       {
100531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100532       };
100533     } catch (Dali::DaliException e) {
100534       {
100535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100536       };
100537     } catch (...) {
100538       {
100539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100540       };
100541     }
100542   }
100543 }
100544
100545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
100546   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100547
100548   arg1 = (Dali::Toolkit::WebView *)jarg1;
100549   {
100550     try {
100551       (arg1)->GoBack();
100552     } catch (std::out_of_range& e) {
100553       {
100554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100555       };
100556     } catch (std::exception& e) {
100557       {
100558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100559       };
100560     } catch (Dali::DaliException e) {
100561       {
100562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100563       };
100564     } catch (...) {
100565       {
100566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100567       };
100568     }
100569   }
100570 }
100571
100572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
100573   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100574
100575   arg1 = (Dali::Toolkit::WebView *)jarg1;
100576   {
100577     try {
100578       (arg1)->GoForward();
100579     } catch (std::out_of_range& e) {
100580       {
100581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100582       };
100583     } catch (std::exception& e) {
100584       {
100585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100586       };
100587     } catch (Dali::DaliException e) {
100588       {
100589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100590       };
100591     } catch (...) {
100592       {
100593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100594       };
100595     }
100596   }
100597 }
100598
100599 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
100600   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100601   bool ret;
100602
100603   arg1 = (Dali::Toolkit::WebView *)jarg1;
100604   {
100605     try {
100606       ret = (arg1)->CanGoBack();
100607     } catch (std::out_of_range& e) {
100608       {
100609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
100610       };
100611     } catch (std::exception& e) {
100612       {
100613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
100614       };
100615     } catch (Dali::DaliException e) {
100616       {
100617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
100618       };
100619     } catch (...) {
100620       {
100621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
100622       };
100623     }
100624   }
100625   return ret;
100626 }
100627
100628 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
100629   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100630   bool ret;
100631
100632   arg1 = (Dali::Toolkit::WebView *)jarg1;
100633   {
100634     try {
100635       ret = (arg1)->CanGoForward();
100636     } catch (std::out_of_range& e) {
100637       {
100638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
100639       };
100640     } catch (std::exception& e) {
100641       {
100642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
100643       };
100644     } catch (Dali::DaliException e) {
100645       {
100646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
100647       };
100648     } catch (...) {
100649       {
100650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
100651       };
100652     }
100653   }
100654   return ret;
100655 }
100656
100657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
100658   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100659   std::string *arg2;
100660
100661   arg1 = (Dali::Toolkit::WebView *)jarg1;
100662   if (!jarg2) {
100663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100664     return;
100665   }
100666   std::string jarg2_str = std::string(jarg2);
100667   arg2 = &jarg2_str;
100668
100669   {
100670     try {
100671       if (jarg3) {
100672         void (*handler)(char*) = (void (*)(char*)) jarg3;
100673         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
100674           handler(SWIG_csharp_string_callback(result.c_str()));
100675         });
100676       } else {
100677         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
100678       }
100679     } catch (std::out_of_range& e) {
100680       {
100681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100682       };
100683     } catch (std::exception& e) {
100684       {
100685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100686       };
100687     } catch (Dali::DaliException e) {
100688       {
100689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100690       };
100691     } catch (...) {
100692       {
100693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100694       };
100695     }
100696   }
100697 }
100698
100699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
100700 {
100701   if (!jarg2) {
100702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100703     return;
100704   }
100705
100706   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
100707   std::string exposedObjectName = jarg2;
100708   void (*handler)(char*) = (void (*)(char*)) jarg3;
100709
100710   {
100711     try {
100712       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
100713         handler(SWIG_csharp_string_callback(message.c_str()));
100714       });
100715     } catch (std::out_of_range& e) {
100716       {
100717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100718       };
100719     } catch (std::exception& e) {
100720       {
100721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100722       };
100723     } catch (Dali::DaliException e) {
100724       {
100725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100726       };
100727     } catch (...) {
100728       {
100729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100730       };
100731     }
100732   }
100733 }
100734
100735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
100736   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100737
100738   arg1 = (Dali::Toolkit::WebView *)jarg1;
100739   {
100740     try {
100741       (arg1)->ClearHistory();
100742     } catch (std::out_of_range& e) {
100743       {
100744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100745       };
100746     } catch (std::exception& e) {
100747       {
100748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100749       };
100750     } catch (Dali::DaliException e) {
100751       {
100752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100753       };
100754     } catch (...) {
100755       {
100756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100757       };
100758     }
100759   }
100760 }
100761
100762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
100763   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100764
100765   arg1 = (Dali::Toolkit::WebView *)jarg1;
100766   {
100767     try {
100768       (arg1)->ClearCache();
100769     } catch (std::out_of_range& e) {
100770       {
100771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100772       };
100773     } catch (std::exception& e) {
100774       {
100775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100776       };
100777     } catch (Dali::DaliException e) {
100778       {
100779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100780       };
100781     } catch (...) {
100782       {
100783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100784       };
100785     }
100786   }
100787 }
100788
100789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
100790   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100791
100792   arg1 = (Dali::Toolkit::WebView *)jarg1;
100793   {
100794     try {
100795       (arg1)->ClearCookies();
100796     } catch (std::out_of_range& e) {
100797       {
100798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100799       };
100800     } catch (std::exception& e) {
100801       {
100802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100803       };
100804     } catch (Dali::DaliException e) {
100805       {
100806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100807       };
100808     } catch (...) {
100809       {
100810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100811       };
100812     }
100813   }
100814 }
100815
100816 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
100817     return (Dali::Toolkit::Control *)jarg1;
100818 }
100819
100820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
100821   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
100822   SignalConverter::WebViewPageLoadSignal* result = NULL;
100823   {
100824     try {
100825       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
100826     } catch (std::out_of_range& e) {
100827       {
100828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100829       };
100830     } catch (std::exception& e) {
100831       {
100832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100833       };
100834     } catch (Dali::DaliException e) {
100835       {
100836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100837       };
100838     } catch (...) {
100839       {
100840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100841       };
100842     }
100843   }
100844   return (void*) result;
100845 }
100846
100847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
100848   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
100849   SignalConverter::WebViewPageLoadSignal* result = NULL;
100850   {
100851     try {
100852       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
100853     } catch (std::out_of_range& e) {
100854       {
100855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100856       };
100857     } catch (std::exception& e) {
100858       {
100859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100860       };
100861     } catch (Dali::DaliException e) {
100862       {
100863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100864       };
100865     } catch (...) {
100866       {
100867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100868       };
100869     }
100870   }
100871   return (void*) result;
100872 }
100873
100874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
100875 {
100876   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
100877   {
100878     try {
100879       delete object;
100880     } catch (std::out_of_range& e) {
100881       {
100882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100883       };
100884     } catch (std::exception& e) {
100885       {
100886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100887       };
100888     } catch (Dali::DaliException e) {
100889       {
100890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100891       };
100892     } catch (...) {
100893       {
100894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100895       };
100896     }
100897   }
100898 }
100899
100900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
100901 {
100902   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
100903   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
100904   {
100905     try {
100906       proxy->Connect(callback);
100907     } catch (std::out_of_range& e) {
100908       {
100909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100910       };
100911     } catch (std::exception& e) {
100912       {
100913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100914       };
100915     } catch (Dali::DaliException e) {
100916       {
100917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100918       };
100919     } catch (...) {
100920       {
100921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100922       };
100923     }
100924   }
100925 }
100926
100927
100928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
100929   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
100930   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
100931   {
100932     try {
100933       proxy->Disconnect(callback);
100934     } catch (std::out_of_range& e) {
100935       {
100936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100937       };
100938     } catch (std::exception& e) {
100939       {
100940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100941       };
100942     } catch (Dali::DaliException e) {
100943       {
100944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100945       };
100946     } catch (...) {
100947       {
100948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100949       };
100950     }
100951   }
100952 }
100953
100954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
100955   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
100956   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
100957   {
100958     try {
100959       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
100960     } catch (std::out_of_range& e) {
100961       {
100962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100963       };
100964     } catch (std::exception& e) {
100965       {
100966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100967       };
100968     } catch (Dali::DaliException e) {
100969       {
100970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100971       };
100972     } catch (...) {
100973       {
100974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100975       };
100976     }
100977   }
100978   return (void*) result;
100979 }
100980
100981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
100982 {
100983   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
100984   {
100985     try {
100986       delete object;
100987     } catch (std::out_of_range& e) {
100988       {
100989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100990       };
100991     } catch (std::exception& e) {
100992       {
100993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100994       };
100995     } catch (Dali::DaliException e) {
100996       {
100997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100998       };
100999     } catch (...) {
101000       {
101001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101002       };
101003     }
101004   }
101005 }
101006
101007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
101008 {
101009   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
101010   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
101011   {
101012     try {
101013       proxy->Connect(callback);
101014     } catch (std::out_of_range& e) {
101015       {
101016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101017       };
101018     } catch (std::exception& e) {
101019       {
101020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101021       };
101022     } catch (Dali::DaliException e) {
101023       {
101024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101025       };
101026     } catch (...) {
101027       {
101028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101029       };
101030     }
101031   }
101032 }
101033
101034
101035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
101036   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
101037   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
101038   {
101039     try {
101040       proxy->Disconnect(callback);
101041     } catch (std::out_of_range& e) {
101042       {
101043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101044       };
101045     } catch (std::exception& e) {
101046       {
101047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101048       };
101049     } catch (Dali::DaliException e) {
101050       {
101051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101052       };
101053     } catch (...) {
101054       {
101055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101056       };
101057     }
101058   }
101059 }
101060
101061 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
101062   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
101063   char * jresult = SWIG_csharp_string_callback((const char *)result);
101064   return jresult;
101065 }
101066
101067 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
101068   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
101069   return result;
101070 }
101071
101072
101073 struct NativeImageSourcePtrHandle
101074 {
101075   NativeImageSourcePtr Ptr;
101076 };
101077
101078 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
101079 {
101080   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
101081   return (NativeImageInterface*)(arg1);
101082 }
101083
101084 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
101085 {
101086   void* jresult;
101087   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
101088   {
101089     try {
101090       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
101091     }
101092     catch (std::out_of_range & e) {
101093       {
101094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101095       };
101096     }
101097     catch (std::exception & e) {
101098       {
101099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101100       };
101101     }
101102     catch (Dali::DaliException e) {
101103       {
101104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101105       };
101106     }
101107     catch (...) {
101108       {
101109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101110       };
101111     }
101112   }
101113   jresult = (void *)handle;
101114   return jresult;
101115 }
101116
101117 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
101118 {
101119   void* jresult;
101120   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
101121   jresult = (void*)( handle->Ptr.Get() );
101122   return jresult;
101123 }
101124
101125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
101126   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
101127   {
101128     try {
101129       delete arg1;
101130     }
101131     catch (std::out_of_range & e) {
101132       {
101133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
101134       };
101135     }
101136     catch (std::exception & e) {
101137       {
101138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
101139       };
101140     }
101141     catch (Dali::DaliException e) {
101142       {
101143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
101144       };
101145     }
101146     catch (...) {
101147       {
101148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
101149       };
101150     }
101151   }
101152 }
101153
101154 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
101155 {
101156   void* jresult;
101157   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
101158   uint16_t* arg2 = (uint16_t*)(jarg2);
101159   uint16_t* arg3 = (uint16_t*)(jarg3);
101160   uint16_t* arg4 = (uint16_t*)(jarg4);
101161   {
101162     try {
101163       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
101164     }
101165     catch (std::out_of_range & e) {
101166       {
101167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101168       };
101169     }
101170     catch (std::exception & e) {
101171       {
101172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101173       };
101174     }
101175     catch (Dali::DaliException e) {
101176       {
101177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101178       };
101179     }
101180     catch (...) {
101181       {
101182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101183       };
101184     }
101185   }
101186   return jresult;
101187 }
101188
101189 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
101190 {
101191   bool jresult;
101192   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
101193
101194   {
101195     try {
101196       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
101197     }
101198     catch (std::out_of_range & e) {
101199       {
101200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101201       };
101202     }
101203     catch (std::exception & e) {
101204       {
101205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101206       };
101207     }
101208     catch (Dali::DaliException e) {
101209       {
101210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101211       };
101212     }
101213     catch (...) {
101214       {
101215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101216       };
101217     }
101218   }
101219   return jresult;
101220 }
101221
101222
101223 #ifdef __cplusplus
101224 }
101225 #endif
101226