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/devel-api/images/nine-patch-image.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456
 457 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 458 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 459 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 460
 461 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 463 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 464
 465 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 466 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 467 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 468
 469 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 470
 471 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 472 #include <dali/devel-api/adaptor-framework/image-loading.h>
 473
 474 #include <dali/public-api/events/mouse-button.h>
 475
 476 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 477 #include "web-view-signal-converter.h"
 478
 479 #include <dali/integration-api/debug.h>
 480
 481 // add here SWIG version check
 482
 483 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 484 // disable Swig-dependent warnings
 485
 486 // 'identifier1' has C-linkage specified,
 487 // but returns UDT 'identifier2' which is incompatible with C
 488 #pragma warning(disable: 4190)
 489
 490 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 491 #pragma warning(disable: 4800)
 492
 493 // debug info too long etc etc
 494 #pragma warning(disable: 4786)
 495 #endif
 496
 497
 498 #include <stdexcept>
 499
 500
 501 #include <string>
 502
 503
 504 #include <vector>
 505 #include <algorithm>
 506 #include <stdexcept>
 507
 508
 509 #include <map>
 510 #include <algorithm>
 511 #include <stdexcept>
 512
 513
 514 #include <utility>
 515
 516
 517 typedef float floatp;
 518
 519 SWIGINTERN floatp *new_floatp(){
 520   return new float();
 521 }
 522 SWIGINTERN void delete_floatp(floatp *self){
 523   if (self) delete self;
 524 }
 525 SWIGINTERN void floatp_assign(floatp *self,float value){
 526   *self = value;
 527 }
 528 SWIGINTERN float floatp_value(floatp *self){
 529   return *self;
 530 }
 531 SWIGINTERN float *floatp_cast(floatp *self){
 532   return self;
 533 }
 534 SWIGINTERN floatp *floatp_frompointer(float *t){
 535   return (floatp *) t;
 536 }
 537
 538 typedef int intp;
 539
 540 SWIGINTERN intp *new_intp(){
 541   return new int();
 542 }
 543 SWIGINTERN void delete_intp(intp *self){
 544   if (self) delete self;
 545 }
 546 SWIGINTERN void intp_assign(intp *self,int value){
 547   *self = value;
 548 }
 549 SWIGINTERN int intp_value(intp *self){
 550   return *self;
 551 }
 552 SWIGINTERN int *intp_cast(intp *self){
 553   return self;
 554 }
 555 SWIGINTERN intp *intp_frompointer(int *t){
 556   return (intp *) t;
 557 }
 558
 559 typedef double doublep;
 560
 561 SWIGINTERN doublep *new_doublep(){
 562   return new double();
 563 }
 564 SWIGINTERN void delete_doublep(doublep *self){
 565   if (self) delete self;
 566 }
 567 SWIGINTERN void doublep_assign(doublep *self,double value){
 568   *self = value;
 569 }
 570 SWIGINTERN double doublep_value(doublep *self){
 571   return *self;
 572 }
 573 SWIGINTERN double *doublep_cast(doublep *self){
 574   return self;
 575 }
 576 SWIGINTERN doublep *doublep_frompointer(double *t){
 577   return (doublep *) t;
 578 }
 579
 580 typedef unsigned int uintp;
 581
 582 SWIGINTERN uintp *new_uintp(){
 583   return new unsigned int();
 584 }
 585 SWIGINTERN void delete_uintp(uintp *self){
 586   if (self) delete self;
 587 }
 588 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 589   *self = value;
 590 }
 591 SWIGINTERN unsigned int uintp_value(uintp *self){
 592   return *self;
 593 }
 594 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 595   return self;
 596 }
 597 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 598   return (uintp *) t;
 599 }
 600
 601 typedef unsigned short ushortp;
 602
 603 SWIGINTERN ushortp *new_ushortp(){
 604   return new unsigned short();
 605 }
 606 SWIGINTERN void delete_ushortp(ushortp *self){
 607   if (self) delete self;
 608 }
 609 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 610   *self = value;
 611 }
 612 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 613   return *self;
 614 }
 615 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 616   return self;
 617 }
 618 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 619   return (ushortp *) t;
 620 }
 621
 622 unsigned int int_to_uint(int x) {
 623    return (unsigned int) x;
 624 }
 625
 626
 627 using namespace Dali;
 628 using namespace Dali::Toolkit;
 629
 630 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 631 {
 632   bool result = false;
 633   try
 634   {
 635     // C++ code. DALi uses Handle <-> Body design pattern.
 636     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 637     // Handles in DALi can be converted into a boolean type
 638     // to check if the handle has a valid body attached to it.
 639     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 640     if( *self )
 641     {
 642       result = true;
 643     }
 644     else
 645     {
 646       result = false;
 647     }
 648   }
 649   catch (std::out_of_range& e)
 650   {
 651     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 652     return 0;
 653   }
 654   catch (std::exception& e)
 655   {
 656     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 657     return 0;
 658   }
 659   catch (DaliException e)
 660   {
 661     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 662     return 0;
 663   }
 664   catch (...)
 665   {
 666     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 667     return 0;
 668   }
 669   return result;
 670 }
 671
 672 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 673 {
 674   bool result = false;
 675   try
 676   {
 677     // C++ code. Check if two handles reference the same implemtion
 678     if( *self == rhs)
 679     {
 680       result = true;
 681     }
 682     else
 683     {
 684       result = false;
 685     }
 686   }
 687   catch (std::out_of_range& e)
 688   {
 689     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 690     return 0;
 691   }
 692   catch (std::exception& e)
 693   {
 694     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 695     return 0;
 696   }
 697   catch (DaliException e)
 698   {
 699     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 700     return 0;
 701   }
 702   catch (...)
 703   {
 704     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 705     return 0;
 706   }
 707   return result;
 708 }
 709
 710
 711 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 712      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 713    }
 714 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){
 715      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 716    }
 717 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 718         std::vector< Dali::TouchPoint >* pv = 0;
 719         if (capacity >= 0) {
 720           pv = new std::vector< Dali::TouchPoint >();
 721           pv->reserve(capacity);
 722        } else {
 723           throw std::out_of_range("capacity");
 724        }
 725        return pv;
 726       }
 727 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 728         if (index>=0 && index<(int)self->size())
 729           return (*self)[index];
 730         else
 731           throw std::out_of_range("index");
 732       }
 733 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 734         if (index>=0 && index<(int)self->size())
 735           return (*self)[index];
 736         else
 737           throw std::out_of_range("index");
 738       }
 739 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 740         if (index>=0 && index<(int)self->size())
 741           (*self)[index] = val;
 742         else
 743           throw std::out_of_range("index");
 744       }
 745 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 746         self->insert(self->end(), values.begin(), values.end());
 747       }
 748 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 749         if (index < 0)
 750           throw std::out_of_range("index");
 751         if (count < 0)
 752           throw std::out_of_range("count");
 753         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 754           throw std::invalid_argument("invalid range");
 755         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 756       }
 757 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 758         if (index>=0 && index<(int)self->size()+1)
 759           self->insert(self->begin()+index, x);
 760         else
 761           throw std::out_of_range("index");
 762       }
 763 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 764         if (index>=0 && index<(int)self->size()+1)
 765           self->insert(self->begin()+index, values.begin(), values.end());
 766         else
 767           throw std::out_of_range("index");
 768       }
 769 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 770         if (index>=0 && index<(int)self->size())
 771           self->erase(self->begin() + index);
 772         else
 773           throw std::out_of_range("index");
 774       }
 775 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 776         if (index < 0)
 777           throw std::out_of_range("index");
 778         if (count < 0)
 779           throw std::out_of_range("count");
 780         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 781           throw std::invalid_argument("invalid range");
 782         self->erase(self->begin()+index, self->begin()+index+count);
 783       }
 784 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 785         if (count < 0)
 786           throw std::out_of_range("count");
 787         return new std::vector< Dali::TouchPoint >(count, value);
 788       }
 789 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 790         std::reverse(self->begin(), self->end());
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 793         if (index < 0)
 794           throw std::out_of_range("index");
 795         if (count < 0)
 796           throw std::out_of_range("count");
 797         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 798           throw std::invalid_argument("invalid range");
 799         std::reverse(self->begin()+index, self->begin()+index+count);
 800       }
 801 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 802         if (index < 0)
 803           throw std::out_of_range("index");
 804         if (index+values.size() > self->size())
 805           throw std::out_of_range("index");
 806         std::copy(values.begin(), values.end(), self->begin()+index);
 807       }
 808 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 809          return self->Empty();
 810       }
 811 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 812         return self->GetConnectionCount();
 813       }
 814 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 815           self->Connect( func );
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Disconnect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 821           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 822 /*@SWIG@*/ self->Emit( arg );
 823       }
 824 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 825          return self->Empty();
 826       }
 827 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828         return self->GetConnectionCount();
 829       }
 830 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 831           self->Connect( func );
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Disconnect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 837           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 838 /*@SWIG@*/ self->Emit( arg );
 839       }
 840 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 841          return self->Empty();
 842       }
 843 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){
 844         return self->GetConnectionCount();
 845       }
 846 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 *)){
 847           self->Connect( func );
 848       }
 849 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 *)){
 850           self->Disconnect( func );
 851       }
 852 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){
 853           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 854 /*@SWIG@*/ self->Emit( arg );
 855       }
 856 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 857          return self->Empty();
 858       }
 859 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860         return self->GetConnectionCount();
 861       }
 862 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 863           self->Connect( func );
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Disconnect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 869           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 870 /*@SWIG@*/ self->Emit( arg );
 871       }
 872 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 873          return self->Empty();
 874       }
 875 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 876         return self->GetConnectionCount();
 877       }
 878 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 879           self->Connect( func );
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 882           self->Disconnect( func );
 883       }
 884 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 885           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 886 /*@SWIG@*/ self->Emit( arg );
 887       }
 888 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){
 889          return self->Empty();
 890       }
 891 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){
 892         return self->GetConnectionCount();
 893       }
 894 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 &)){
 895         self->Connect( func );
 896       }
 897 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 &)){
 898         self->Disconnect( func );
 899       }
 900 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){
 901         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 902 /*@SWIG@*/ self->Emit( arg1, arg2 );
 903       }
 904 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){
 905          return self->Empty();
 906       }
 907 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){
 908         return self->GetConnectionCount();
 909       }
 910 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 &)){
 911         self->Connect( func );
 912       }
 913 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 &)){
 914         self->Disconnect( func );
 915       }
 916 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){
 917         return self->Emit( arg1, arg2 );
 918       }
 919 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){
 920          return self->Empty();
 921       }
 922 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){
 923         return self->GetConnectionCount();
 924       }
 925 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 &)){
 926         self->Connect( func );
 927       }
 928 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 &)){
 929         self->Disconnect( func );
 930       }
 931 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){
 932         return self->Emit( arg1, arg2 );
 933       }
 934 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){
 935          return self->Empty();
 936       }
 937 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){
 938         return self->GetConnectionCount();
 939       }
 940 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 &)){
 941         self->Connect( func );
 942       }
 943 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 &)){
 944         self->Disconnect( func );
 945       }
 946 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){
 947         return self->Emit( arg1, arg2 );
 948       }
 949 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 950          return self->Empty();
 951       }
 952 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 953         return self->GetConnectionCount();
 954       }
 955 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 956           self->Connect( func );
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 959           self->Disconnect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 962           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 963 /*@SWIG@*/ self->Emit( arg );
 964       }
 965 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 966          return self->Empty();
 967       }
 968 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){
 969         return self->GetConnectionCount();
 970       }
 971 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 &)){
 972           self->Connect( func );
 973       }
 974 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 &)){
 975           self->Disconnect( func );
 976       }
 977 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){
 978           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 979 /*@SWIG@*/ self->Emit( arg );
 980       }
 981 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 982          return self->Empty();
 983       }
 984 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){
 985         return self->GetConnectionCount();
 986       }
 987 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 &)){
 988           self->Connect( func );
 989       }
 990 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 &)){
 991           self->Disconnect( func );
 992       }
 993 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){
 994           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 995 /*@SWIG@*/ self->Emit( arg );
 996       }
 997 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 998          return self->Empty();
 999       }
1000 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){
1001         return self->GetConnectionCount();
1002       }
1003 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 &)){
1004           self->Connect( func );
1005       }
1006 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 &)){
1007           self->Disconnect( func );
1008       }
1009 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){
1010           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1011 /*@SWIG@*/ self->Emit( arg );
1012       }
1013 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){
1014          return self->Empty();
1015       }
1016 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){
1017         return self->GetConnectionCount();
1018       }
1019 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 &)){
1020         self->Connect( func );
1021       }
1022 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 &)){
1023         self->Disconnect( func );
1024       }
1025 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){
1026         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1027 /*@SWIG@*/ self->Emit( arg1, arg2 );
1028       }
1029 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){
1030          return self->Empty();
1031       }
1032 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){
1033         return self->GetConnectionCount();
1034       }
1035 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 &)){
1036         self->Connect( func );
1037       }
1038 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 &)){
1039         self->Disconnect( func );
1040       }
1041 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){
1042         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1043 /*@SWIG@*/ self->Emit( arg1, arg2 );
1044       }
1045 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){
1046          return self->Empty();
1047       }
1048 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){
1049         return self->GetConnectionCount();
1050       }
1051 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 &)){
1052         self->Connect( func );
1053       }
1054 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 &)){
1055         self->Disconnect( func );
1056       }
1057 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){
1058         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1059 /*@SWIG@*/ self->Emit( arg1, arg2 );
1060       }
1061 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1062          return self->Empty();
1063       }
1064 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1065         return self->GetConnectionCount();
1066       }
1067 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1068           self->Connect( func );
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1071           self->Disconnect( func );
1072       }
1073 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1074           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1075 /*@SWIG@*/ self->Emit( arg );
1076       }
1077 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){
1078          return self->Empty();
1079       }
1080 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){
1081         return self->GetConnectionCount();
1082       }
1083 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)){
1084           return self->Connect( func );
1085       }
1086 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)){
1087           self->Disconnect( func );
1088       }
1089 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){
1090           self->Emit( arg1, arg3 );
1091       }
1092 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){
1093          return self->Empty();
1094       }
1095 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){
1096         return self->GetConnectionCount();
1097       }
1098 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)){
1099           return self->Connect( func );
1100       }
1101 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)){
1102           self->Disconnect( func );
1103       }
1104 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){
1105           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1106 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1107       }
1108
1109 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1110          return self->Empty();
1111       }
1112 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1113         return self->GetConnectionCount();
1114       }
1115 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1116           self->Connect( func );
1117       }
1118 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1119           self->Disconnect( func );
1120       }
1121 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1122           return self->Emit();
1123       }
1124
1125 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1126         std::vector< unsigned int >* pv = 0;
1127         if (capacity >= 0) {
1128           pv = new std::vector< unsigned int >();
1129           pv->reserve(capacity);
1130        } else {
1131           throw std::out_of_range("capacity");
1132        }
1133        return pv;
1134       }
1135 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1136         if (index>=0 && index<(int)self->size())
1137           return (*self)[index];
1138         else
1139           throw std::out_of_range("index");
1140       }
1141 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1142         if (index>=0 && index<(int)self->size())
1143           return (*self)[index];
1144         else
1145           throw std::out_of_range("index");
1146       }
1147 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1148         if (index>=0 && index<(int)self->size())
1149           (*self)[index] = val;
1150         else
1151           throw std::out_of_range("index");
1152       }
1153 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1154         self->insert(self->end(), values.begin(), values.end());
1155       }
1156 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1157         if (index < 0)
1158           throw std::out_of_range("index");
1159         if (count < 0)
1160           throw std::out_of_range("count");
1161         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1162           throw std::invalid_argument("invalid range");
1163         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1164       }
1165 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1166         if (index>=0 && index<(int)self->size()+1)
1167           self->insert(self->begin()+index, x);
1168         else
1169           throw std::out_of_range("index");
1170       }
1171 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1172         if (index>=0 && index<(int)self->size()+1)
1173           self->insert(self->begin()+index, values.begin(), values.end());
1174         else
1175           throw std::out_of_range("index");
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1178         if (index>=0 && index<(int)self->size())
1179           self->erase(self->begin() + index);
1180         else
1181           throw std::out_of_range("index");
1182       }
1183 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1184         if (index < 0)
1185           throw std::out_of_range("index");
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1189           throw std::invalid_argument("invalid range");
1190         self->erase(self->begin()+index, self->begin()+index+count);
1191       }
1192 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1193         if (count < 0)
1194           throw std::out_of_range("count");
1195         return new std::vector< unsigned int >(count, value);
1196       }
1197 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1198         std::reverse(self->begin(), self->end());
1199       }
1200 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (count < 0)
1204           throw std::out_of_range("count");
1205         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1206           throw std::invalid_argument("invalid range");
1207         std::reverse(self->begin()+index, self->begin()+index+count);
1208       }
1209 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1210         if (index < 0)
1211           throw std::out_of_range("index");
1212         if (index+values.size() > self->size())
1213           throw std::out_of_range("index");
1214         std::copy(values.begin(), values.end(), self->begin()+index);
1215       }
1216 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1217         return std::find(self->begin(), self->end(), value) != self->end();
1218       }
1219 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1220         int index = -1;
1221         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1222         if (it != self->end())
1223           index = (int)(it - self->begin());
1224         return index;
1225       }
1226 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1227         int index = -1;
1228         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1229         if (rit != self->rend())
1230           index = (int)(self->rend() - 1 - rit);
1231         return index;
1232       }
1233 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1234         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1235         if (it != self->end()) {
1236           self->erase(it);
1237           return true;
1238         }
1239         return false;
1240       }
1241 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){
1242         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1243         if (capacity >= 0) {
1244           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1245           pv->reserve(capacity);
1246        } else {
1247           throw std::out_of_range("capacity");
1248        }
1249        return pv;
1250       }
1251 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){
1252         if (index>=0 && index<(int)self->size())
1253           return (*self)[index];
1254         else
1255           throw std::out_of_range("index");
1256       }
1257 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){
1258         if (index>=0 && index<(int)self->size())
1259           return (*self)[index];
1260         else
1261           throw std::out_of_range("index");
1262       }
1263 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){
1264         if (index>=0 && index<(int)self->size())
1265           (*self)[index] = val;
1266         else
1267           throw std::out_of_range("index");
1268       }
1269 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){
1270         self->insert(self->end(), values.begin(), values.end());
1271       }
1272 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){
1273         if (index < 0)
1274           throw std::out_of_range("index");
1275         if (count < 0)
1276           throw std::out_of_range("count");
1277         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1278           throw std::invalid_argument("invalid range");
1279         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1280       }
1281 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){
1282         if (index>=0 && index<(int)self->size()+1)
1283           self->insert(self->begin()+index, x);
1284         else
1285           throw std::out_of_range("index");
1286       }
1287 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){
1288         if (index>=0 && index<(int)self->size()+1)
1289           self->insert(self->begin()+index, values.begin(), values.end());
1290         else
1291           throw std::out_of_range("index");
1292       }
1293 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){
1294         if (index>=0 && index<(int)self->size())
1295           self->erase(self->begin() + index);
1296         else
1297           throw std::out_of_range("index");
1298       }
1299 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){
1300         if (index < 0)
1301           throw std::out_of_range("index");
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1305           throw std::invalid_argument("invalid range");
1306         self->erase(self->begin()+index, self->begin()+index+count);
1307       }
1308 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){
1309         if (count < 0)
1310           throw std::out_of_range("count");
1311         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1312       }
1313 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){
1314         std::reverse(self->begin(), self->end());
1315       }
1316 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){
1317         if (index < 0)
1318           throw std::out_of_range("index");
1319         if (count < 0)
1320           throw std::out_of_range("count");
1321         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1322           throw std::invalid_argument("invalid range");
1323         std::reverse(self->begin()+index, self->begin()+index+count);
1324       }
1325 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){
1326         if (index < 0)
1327           throw std::out_of_range("index");
1328         if (index+values.size() > self->size())
1329           throw std::out_of_range("index");
1330         std::copy(values.begin(), values.end(), self->begin()+index);
1331       }
1332 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1333         std::vector< Dali::Actor >* pv = 0;
1334         if (capacity >= 0) {
1335           pv = new std::vector< Dali::Actor >();
1336           pv->reserve(capacity);
1337        } else {
1338           throw std::out_of_range("capacity");
1339        }
1340        return pv;
1341       }
1342 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1343         if (index>=0 && index<(int)self->size())
1344           return (*self)[index];
1345         else
1346           throw std::out_of_range("index");
1347       }
1348 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1349         if (index>=0 && index<(int)self->size())
1350           return (*self)[index];
1351         else
1352           throw std::out_of_range("index");
1353       }
1354 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1355         if (index>=0 && index<(int)self->size())
1356           (*self)[index] = val;
1357         else
1358           throw std::out_of_range("index");
1359       }
1360 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1361         self->insert(self->end(), values.begin(), values.end());
1362       }
1363 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1364         if (index < 0)
1365           throw std::out_of_range("index");
1366         if (count < 0)
1367           throw std::out_of_range("count");
1368         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1369           throw std::invalid_argument("invalid range");
1370         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1371       }
1372 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1373         if (index>=0 && index<(int)self->size()+1)
1374           self->insert(self->begin()+index, x);
1375         else
1376           throw std::out_of_range("index");
1377       }
1378 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1379         if (index>=0 && index<(int)self->size()+1)
1380           self->insert(self->begin()+index, values.begin(), values.end());
1381         else
1382           throw std::out_of_range("index");
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1385         if (index>=0 && index<(int)self->size())
1386           self->erase(self->begin() + index);
1387         else
1388           throw std::out_of_range("index");
1389       }
1390 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1391         if (index < 0)
1392           throw std::out_of_range("index");
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1396           throw std::invalid_argument("invalid range");
1397         self->erase(self->begin()+index, self->begin()+index+count);
1398       }
1399 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1400         if (count < 0)
1401           throw std::out_of_range("count");
1402         return new std::vector< Dali::Actor >(count, value);
1403       }
1404 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1405         std::reverse(self->begin(), self->end());
1406       }
1407 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1408         if (index < 0)
1409           throw std::out_of_range("index");
1410         if (count < 0)
1411           throw std::out_of_range("count");
1412         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1413           throw std::invalid_argument("invalid range");
1414         std::reverse(self->begin()+index, self->begin()+index+count);
1415       }
1416 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1417         if (index < 0)
1418           throw std::out_of_range("index");
1419         if (index+values.size() > self->size())
1420           throw std::out_of_range("index");
1421         std::copy(values.begin(), values.end(), self->begin()+index);
1422       }
1423 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1424          return self->Empty();
1425       }
1426 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1427         return self->GetConnectionCount();
1428       }
1429 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 &)){
1430           self->Connect( func );
1431       }
1432 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 &)){
1433           self->Disconnect( func );
1434       }
1435 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){
1436           return self->Emit( arg );
1437       }
1438 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){
1439          return self->Empty();
1440       }
1441 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){
1442         return self->GetConnectionCount();
1443       }
1444 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)){
1445         self->Connect( func );
1446       }
1447 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)){
1448         self->Disconnect( func );
1449       }
1450 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){
1451         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1452 /*@SWIG@*/ self->Emit( arg1, arg2 );
1453       }
1454 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1455          return self->Empty();
1456       }
1457 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){
1458         return self->GetConnectionCount();
1459       }
1460 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)){
1461         self->Connect( func );
1462       }
1463 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)){
1464         self->Disconnect( func );
1465       }
1466 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){
1467         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1468 /*@SWIG@*/ self->Emit( arg1, arg2 );
1469       }
1470 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1471          return self->Empty();
1472       }
1473 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1474         return self->GetConnectionCount();
1475       }
1476 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)){
1477         self->Connect( func );
1478       }
1479 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)){
1480         self->Disconnect( func );
1481       }
1482 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){
1483         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1484 /*@SWIG@*/ self->Emit( arg1, arg2 );
1485       }
1486 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){
1487          return self->Empty();
1488       }
1489 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){
1490         return self->GetConnectionCount();
1491       }
1492 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)){
1493         self->Connect( func );
1494       }
1495 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)){
1496         self->Disconnect( func );
1497       }
1498 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){
1499         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1500 /*@SWIG@*/ self->Emit( arg1, arg2 );
1501       }
1502 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1503          return self->Empty();
1504       }
1505 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1506         return self->GetConnectionCount();
1507       }
1508 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)){
1509           self->Connect( func );
1510       }
1511 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)){
1512           self->Disconnect( func );
1513       }
1514 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1515           return self->Emit( arg );
1516       }
1517 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1518          return self->Empty();
1519       }
1520 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1521         return self->GetConnectionCount();
1522       }
1523 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)){
1524           self->Connect( func );
1525       }
1526 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)){
1527           self->Disconnect( func );
1528       }
1529 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1530           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1531 /*@SWIG@*/ self->Emit( arg );
1532       }
1533 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){
1534          return self->Empty();
1535       }
1536 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){
1537         return self->GetConnectionCount();
1538       }
1539 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)){
1540           return self->Connect( func );
1541       }
1542 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)){
1543           self->Disconnect( func );
1544       }
1545 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){
1546           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1547 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1548       }
1549 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1550          return self->Empty();
1551       }
1552 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1553         return self->GetConnectionCount();
1554       }
1555 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)){
1556           self->Connect( func );
1557       }
1558 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)){
1559           self->Disconnect( func );
1560       }
1561 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1562           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1563 /*@SWIG@*/ self->Emit( arg );
1564       }
1565 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){
1566          return self->Empty();
1567       }
1568 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){
1569         return self->GetConnectionCount();
1570       }
1571 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)){
1572           return self->Connect( func );
1573       }
1574 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)){
1575           self->Disconnect( func );
1576       }
1577 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){
1578           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1579 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1580       }
1581 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){
1582          return self->Empty();
1583       }
1584 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){
1585         return self->GetConnectionCount();
1586       }
1587 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 &)){
1588           self->Connect( func );
1589       }
1590 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 &)){
1591           self->Disconnect( func );
1592       }
1593 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){
1594           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1595 /*@SWIG@*/ self->Emit( arg );
1596       }
1597 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1598          return self->Empty();
1599       }
1600 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){
1601         return self->GetConnectionCount();
1602       }
1603 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 &)){
1604           self->Connect( func );
1605       }
1606 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 &)){
1607           self->Disconnect( func );
1608       }
1609 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){
1610           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1611 /*@SWIG@*/ self->Emit( arg );
1612       }
1613
1614
1615 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){
1616          return self->Empty();
1617       }
1618 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){
1619         return self->GetConnectionCount();
1620       }
1621 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 &)){
1622         self->Connect( func );
1623       }
1624 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 &)){
1625         self->Disconnect( func );
1626       }
1627 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){
1628         return self->Emit( arg1, arg2 );
1629       }
1630 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1631          return self->Empty();
1632       }
1633 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1634         return self->GetConnectionCount();
1635       }
1636 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)){
1637           self->Connect( func );
1638       }
1639 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)){
1640           self->Disconnect( func );
1641       }
1642 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1643           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1644 /*@SWIG@*/ self->Emit( arg );
1645       }
1646 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1647          return self->Empty();
1648       }
1649 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1650         return self->GetConnectionCount();
1651       }
1652 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 &)){
1653           self->Connect( func );
1654       }
1655 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 &)){
1656           self->Disconnect( func );
1657       }
1658 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){
1659           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1660 /*@SWIG@*/ self->Emit( arg );
1661       }
1662 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1663          return self->Empty();
1664       }
1665 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){
1666         return self->GetConnectionCount();
1667       }
1668 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)){
1669         self->Connect( func );
1670       }
1671 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)){
1672         self->Disconnect( func );
1673       }
1674 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){
1675         return self->Emit( arg1, arg2 );
1676       }
1677 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1678          return self->Empty();
1679       }
1680 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){
1681         return self->GetConnectionCount();
1682       }
1683 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)){
1684         self->Connect( func );
1685       }
1686 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)){
1687         self->Disconnect( func );
1688       }
1689 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){
1690         return self->Emit( arg1, arg2 );
1691       }
1692
1693 /* ---------------------------------------------------
1694  * C++ director class methods
1695  * --------------------------------------------------- */
1696
1697 #include "dali_wrap.h"
1698
1699 /*
1700  *  Widget director
1701  */
1702 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1703   swig_init_callbacks();
1704 }
1705
1706 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1707 }
1708
1709 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1710   char * jcontentInfo = 0 ;
1711   void * jwindow  ;
1712
1713   if (!swig_callbackOnCreate) {
1714     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1715     return;
1716   } else {
1717     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1718     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1719     swig_callbackOnCreate(jcontentInfo, jwindow);
1720   }
1721 }
1722
1723 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1724   char * jcontentInfo = 0 ;
1725   int jtype  ;
1726
1727   if (!swig_callbackOnTerminate) {
1728     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1729     return;
1730   } else {
1731     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1732     jtype = (int)type;
1733     swig_callbackOnTerminate(jcontentInfo, jtype);
1734   }
1735 }
1736
1737 void SwigDirector_WidgetImpl::OnPause() {
1738   if (!swig_callbackOnPause) {
1739     Dali::Internal::Adaptor::Widget::OnPause();
1740     return;
1741   } else {
1742     swig_callbackOnPause();
1743   }
1744 }
1745
1746 void SwigDirector_WidgetImpl::OnResume() {
1747   if (!swig_callbackOnResume) {
1748     Dali::Internal::Adaptor::Widget::OnResume();
1749     return;
1750   } else {
1751     swig_callbackOnResume();
1752   }
1753 }
1754
1755 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1756   void * jwindow  ;
1757
1758   if (!swig_callbackOnResize) {
1759     Dali::Internal::Adaptor::Widget::OnResize(window);
1760     return;
1761   } else {
1762     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1763     swig_callbackOnResize(jwindow);
1764   }
1765 }
1766
1767 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1768   char * jcontentInfo = 0 ;
1769   int jforce  ;
1770
1771   if (!swig_callbackOnUpdate) {
1772     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1773     return;
1774   } else {
1775     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1776     jforce = force;
1777     swig_callbackOnUpdate(jcontentInfo, jforce);
1778   }
1779 }
1780
1781 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1782   void * jslotObserver = 0 ;
1783   void * jcallback = 0 ;
1784
1785   if (!swig_callbackSignalConnected) {
1786     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1787     return;
1788   } else {
1789     jslotObserver = (void *) slotObserver;
1790     jcallback = (void *) callback;
1791     swig_callbackSignalConnected(jslotObserver, jcallback);
1792   }
1793 }
1794
1795 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1796   void * jslotObserver = 0 ;
1797   void * jcallback = 0 ;
1798
1799   if (!swig_callbackSignalDisconnected) {
1800     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1801     return;
1802   } else {
1803     jslotObserver = (void *) slotObserver;
1804     jcallback = (void *) callback;
1805     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1806   }
1807 }
1808
1809 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) {
1810
1811   swig_callbackOnCreate = callbackOnCreate;
1812   swig_callbackOnTerminate = callbackOnTerminate;
1813   swig_callbackOnPause = callbackOnPause;
1814   swig_callbackOnResume = callbackOnResume;
1815   swig_callbackOnResize = callbackOnResize;
1816   swig_callbackOnUpdate = callbackOnUpdate;
1817   swig_callbackSignalConnected = callbackSignalConnected;
1818   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1819 }
1820
1821 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1822   swig_callbackOnCreate = 0;
1823   swig_callbackOnTerminate = 0;
1824   swig_callbackOnPause = 0;
1825   swig_callbackOnResume = 0;
1826   swig_callbackOnResize = 0;
1827   swig_callbackOnUpdate = 0;
1828   swig_callbackSignalConnected = 0;
1829   swig_callbackSignalDisconnected = 0;
1830 }
1831
1832
1833 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1834   swig_init_callbacks();
1835 }
1836
1837 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1838
1839 }
1840
1841
1842 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1843   int jdepth  ;
1844
1845   if (!swig_callbackOnStageConnection) {
1846     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1847     return;
1848   } else {
1849     jdepth = depth;
1850     swig_callbackOnStageConnection(jdepth);
1851   }
1852 }
1853
1854 void SwigDirector_ViewImpl::OnStageDisconnection() {
1855   if (!swig_callbackOnStageDisconnection) {
1856     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1857     return;
1858   } else {
1859     swig_callbackOnStageDisconnection();
1860   }
1861 }
1862
1863 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1864   void * jchild = 0 ;
1865
1866   if (!swig_callbackOnChildAdd) {
1867     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1868     return;
1869   } else {
1870     jchild = (Dali::Actor *) &child;
1871     swig_callbackOnChildAdd(jchild);
1872   }
1873 }
1874
1875 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1876   void * jchild = 0 ;
1877
1878   if (!swig_callbackOnChildRemove) {
1879     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1880     return;
1881   } else {
1882     jchild = (Dali::Actor *) &child;
1883     swig_callbackOnChildRemove(jchild);
1884   }
1885 }
1886
1887 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1888   int jindex  ;
1889   void * jpropertyValue  ;
1890
1891   if (!swig_callbackOnPropertySet) {
1892     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1893     return;
1894   } else {
1895     jindex = index;
1896     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1897     swig_callbackOnPropertySet(jindex, jpropertyValue);
1898   }
1899 }
1900
1901 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1902   void * jtargetSize = 0 ;
1903
1904   if (!swig_callbackOnSizeSet) {
1905     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1906     return;
1907   } else {
1908     jtargetSize = (Dali::Vector3 *) &targetSize;
1909     swig_callbackOnSizeSet(jtargetSize);
1910   }
1911 }
1912
1913 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1914   void * janimation = 0 ;
1915   void * jtargetSize = 0 ;
1916
1917   if (!swig_callbackOnSizeAnimation) {
1918     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1919     return;
1920   } else {
1921     janimation = (Dali::Animation *) &animation;
1922     jtargetSize = (Dali::Vector3 *) &targetSize;
1923     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1924   }
1925 }
1926
1927 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1928   bool c_result = SwigValueInit< bool >() ;
1929   unsigned int jresult = 0 ;
1930   void * jarg0 = 0 ;
1931
1932   if (!swig_callbackOnTouchEvent) {
1933     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1934   } else {
1935     jarg0 = (Dali::TouchEvent *) &event;
1936     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1937     c_result = jresult ? true : false;
1938   }
1939   return c_result;
1940 }
1941
1942 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1943   bool c_result = SwigValueInit< bool >() ;
1944   unsigned int jresult = 0 ;
1945   void * jarg0 = 0 ;
1946
1947   if (!swig_callbackOnHoverEvent) {
1948     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1949   } else {
1950     jarg0 = (Dali::HoverEvent *) &event;
1951     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1952     c_result = jresult ? true : false;
1953   }
1954   return c_result;
1955 }
1956
1957 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1958   bool c_result = SwigValueInit< bool >() ;
1959   unsigned int jresult = 0 ;
1960   void * jarg0 = 0 ;
1961
1962   if (!swig_callbackOnKeyEvent) {
1963     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1964   } else {
1965     jarg0 = (Dali::KeyEvent *) &event;
1966     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1967     c_result = jresult ? true : false;
1968   }
1969   return c_result;
1970 }
1971
1972 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1973   bool c_result = SwigValueInit< bool >() ;
1974   unsigned int jresult = 0 ;
1975   void * jarg0 = 0 ;
1976
1977   if (!swig_callbackOnWheelEvent) {
1978     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1979   } else {
1980     jarg0 = (Dali::WheelEvent *) &event;
1981     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1982     c_result = jresult ? true : false;
1983   }
1984   return c_result;
1985 }
1986
1987 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1988   void * jsize = 0 ;
1989   void * jcontainer = 0 ;
1990
1991   if (!swig_callbackOnRelayout) {
1992     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1993     return;
1994   } else {
1995     jsize = (Dali::Vector2 *) &size;
1996     jcontainer = (Dali::RelayoutContainer *) &container;
1997     swig_callbackOnRelayout(jsize, jcontainer);
1998   }
1999 }
2000
2001 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2002   int jpolicy  ;
2003   int jdimension  ;
2004
2005   if (!swig_callbackOnSetResizePolicy) {
2006     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2007     return;
2008   } else {
2009     jpolicy = (int)policy;
2010     jdimension = (int)dimension;
2011     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2012   }
2013 }
2014
2015 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2016   Dali::Vector3 c_result ;
2017   void * jresult = 0 ;
2018
2019   if (!swig_callbackGetNaturalSize) {
2020     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2021   } else {
2022     jresult = (void *) swig_callbackGetNaturalSize();
2023     if (!jresult) {
2024       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2025       return c_result;
2026     }
2027     c_result = *(Dali::Vector3 *)jresult;
2028   }
2029   return c_result;
2030 }
2031
2032 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2033   float c_result = SwigValueInit< float >() ;
2034   float jresult = 0 ;
2035   void * jchild = 0 ;
2036   int jdimension  ;
2037
2038   if (!swig_callbackCalculateChildSize) {
2039     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2040   } else {
2041     jchild = (Dali::Actor *) &child;
2042     jdimension = (int)dimension;
2043     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2044     c_result = (float)jresult;
2045   }
2046   return c_result;
2047 }
2048
2049 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2050   float c_result = SwigValueInit< float >() ;
2051   float jresult = 0 ;
2052   float jwidth  ;
2053
2054   if (!swig_callbackGetHeightForWidth) {
2055     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2056   } else {
2057     jwidth = width;
2058     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2059     c_result = (float)jresult;
2060   }
2061   return c_result;
2062 }
2063
2064 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2065   float c_result = SwigValueInit< float >() ;
2066   float jresult = 0 ;
2067   float jheight  ;
2068
2069   if (!swig_callbackGetWidthForHeight) {
2070     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2071   } else {
2072     jheight = height;
2073     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2074     c_result = (float)jresult;
2075   }
2076   return c_result;
2077 }
2078
2079 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2080   bool c_result = SwigValueInit< bool >() ;
2081   unsigned int jresult = 0 ;
2082   int jdimension  ;
2083
2084   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2085     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2086   } else {
2087     jdimension = (int)dimension;
2088     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2089     c_result = jresult ? true : false;
2090   }
2091   return c_result;
2092 }
2093
2094 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2095   int jdimension  ;
2096
2097   if (!swig_callbackOnCalculateRelayoutSize) {
2098     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2099     return;
2100   } else {
2101     jdimension = (int)dimension;
2102     swig_callbackOnCalculateRelayoutSize(jdimension);
2103   }
2104 }
2105
2106 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2107   float jsize  ;
2108   int jdimension  ;
2109
2110   if (!swig_callbackOnLayoutNegotiated) {
2111     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2112     return;
2113   } else {
2114     jsize = size;
2115     jdimension = (int)dimension;
2116     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2117   }
2118 }
2119
2120 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2121   return Dali::CustomActorImpl::GetExtension();
2122 }
2123
2124 void SwigDirector_ViewImpl::OnInitialize() {
2125   if (!swig_callbackOnInitialize) {
2126     Dali::Toolkit::Internal::Control::OnInitialize();
2127     return;
2128   } else {
2129     swig_callbackOnInitialize();
2130   }
2131 }
2132
2133 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2134   void * jchild = 0 ;
2135
2136   if (!swig_callbackOnControlChildAdd) {
2137     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2138     return;
2139   } else {
2140     jchild = (Dali::Actor *) &child;
2141     swig_callbackOnControlChildAdd(jchild);
2142   }
2143 }
2144
2145 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2146   void * jchild = 0 ;
2147
2148   if (!swig_callbackOnControlChildRemove) {
2149     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2150     return;
2151   } else {
2152     jchild = (Dali::Actor *) &child;
2153     swig_callbackOnControlChildRemove(jchild);
2154   }
2155 }
2156
2157 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2158   void * jstyleManager  ;
2159   int jchange  ;
2160
2161   if (!swig_callbackOnStyleChange) {
2162     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2163     return;
2164   } else {
2165     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2166     jchange = (int)change;
2167     swig_callbackOnStyleChange(jstyleManager, jchange);
2168   }
2169 }
2170
2171 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2172   bool c_result = SwigValueInit< bool >() ;
2173   unsigned int jresult = 0 ;
2174
2175   if (!swig_callbackOnAccessibilityActivated) {
2176     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2177   } else {
2178     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2179     c_result = jresult ? true : false;
2180   }
2181   return c_result;
2182 }
2183
2184 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2185   bool c_result = SwigValueInit< bool >() ;
2186   unsigned int jresult = 0 ;
2187   void * jgesture  ;
2188
2189   if (!swig_callbackOnAccessibilityPan) {
2190     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2191   } else {
2192     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2193     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2194     c_result = jresult ? true : false;
2195   }
2196   return c_result;
2197 }
2198
2199 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2200   bool c_result = SwigValueInit< bool >() ;
2201   unsigned int jresult = 0 ;
2202   void * jtouchEvent = 0 ;
2203
2204   if (!swig_callbackOnAccessibilityTouch) {
2205     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2206   } else {
2207     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2208     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2209     c_result = jresult ? true : false;
2210   }
2211   return c_result;
2212 }
2213
2214 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2215   bool c_result = SwigValueInit< bool >() ;
2216   unsigned int jresult = 0 ;
2217   unsigned int jisIncrease  ;
2218
2219   if (!swig_callbackOnAccessibilityValueChange) {
2220     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2221   } else {
2222     jisIncrease = isIncrease;
2223     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2224     c_result = jresult ? true : false;
2225   }
2226   return c_result;
2227 }
2228
2229 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2230   bool c_result = SwigValueInit< bool >() ;
2231   unsigned int jresult = 0 ;
2232
2233   if (!swig_callbackOnAccessibilityZoom) {
2234     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2235   } else {
2236     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2237     c_result = jresult ? true : false;
2238   }
2239   return c_result;
2240 }
2241
2242 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2243   if (!swig_callbackOnKeyInputFocusGained) {
2244     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2245     return;
2246   } else {
2247     swig_callbackOnKeyInputFocusGained();
2248   }
2249 }
2250
2251 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2252   if (!swig_callbackOnKeyInputFocusLost) {
2253     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2254     return;
2255   } else {
2256     swig_callbackOnKeyInputFocusLost();
2257   }
2258 }
2259
2260 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2261   Dali::Actor c_result ;
2262   void * jresult = 0 ;
2263   void * jcurrentFocusedActor  ;
2264   int jdirection  ;
2265   unsigned int jloopEnabled  ;
2266
2267   if (!swig_callbackGetNextKeyboardFocusableActor) {
2268     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2269   } else {
2270     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2271     jdirection = (int)direction;
2272     jloopEnabled = loopEnabled;
2273     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2274     if (!jresult) {
2275       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2276       return c_result;
2277     }
2278     c_result = *(Dali::Actor *)jresult;
2279   }
2280   return c_result;
2281 }
2282
2283 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2284   void * jcommitedFocusableActor  ;
2285
2286   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2287     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2288     return;
2289   } else {
2290     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2291     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2292   }
2293 }
2294
2295 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2296   bool c_result = SwigValueInit< bool >() ;
2297   unsigned int jresult = 0 ;
2298
2299   if (!swig_callbackOnKeyboardEnter) {
2300     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2301   } else {
2302     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2303     c_result = jresult ? true : false;
2304   }
2305   return c_result;
2306 }
2307
2308 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2309   void * jpinch = 0 ;
2310
2311   if (!swig_callbackOnPinch) {
2312     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2313     return;
2314   } else {
2315     jpinch = (Dali::PinchGesture *) &pinch;
2316     swig_callbackOnPinch(jpinch);
2317   }
2318 }
2319
2320 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2321   void * jpan = 0 ;
2322
2323   if (!swig_callbackOnPan) {
2324     Dali::Toolkit::Internal::Control::OnPan(pan);
2325     return;
2326   } else {
2327     jpan = (Dali::PanGesture *) &pan;
2328     swig_callbackOnPan(jpan);
2329   }
2330 }
2331
2332 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2333   void * jtap = 0 ;
2334
2335   if (!swig_callbackOnTap) {
2336     Dali::Toolkit::Internal::Control::OnTap(tap);
2337     return;
2338   } else {
2339     jtap = (Dali::TapGesture *) &tap;
2340     swig_callbackOnTap(jtap);
2341   }
2342 }
2343
2344 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2345   void * jlongPress = 0 ;
2346
2347   if (!swig_callbackOnLongPress) {
2348     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2349     return;
2350   } else {
2351     jlongPress = (Dali::LongPressGesture *) &longPress;
2352     swig_callbackOnLongPress(jlongPress);
2353   }
2354 }
2355
2356 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2357   void * jslotObserver = 0 ;
2358   void * jcallback = 0 ;
2359
2360   if (!swig_callbackSignalConnected) {
2361     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2362     return;
2363   } else {
2364     jslotObserver = (void *) slotObserver;
2365     jcallback = (void *) callback;
2366     swig_callbackSignalConnected(jslotObserver, jcallback);
2367   }
2368 }
2369
2370 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2371   void * jslotObserver = 0 ;
2372   void * jcallback = 0 ;
2373
2374   if (!swig_callbackSignalDisconnected) {
2375     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2376     return;
2377   } else {
2378     jslotObserver = (void *) slotObserver;
2379     jcallback = (void *) callback;
2380     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2381   }
2382 }
2383
2384 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2385   return Dali::Toolkit::Internal::Control::GetControlExtension();
2386 }
2387
2388 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) {
2389   swig_callbackOnStageConnection = callbackOnStageConnection;
2390   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2391   swig_callbackOnChildAdd = callbackOnChildAdd;
2392   swig_callbackOnChildRemove = callbackOnChildRemove;
2393   swig_callbackOnPropertySet = callbackOnPropertySet;
2394   swig_callbackOnSizeSet = callbackOnSizeSet;
2395   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2396   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2397   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2398   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2399   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2400   swig_callbackOnRelayout = callbackOnRelayout;
2401   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2402   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2403   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2404   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2405   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2406   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2407   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2408   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2409   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2410   swig_callbackOnInitialize = callbackOnInitialize;
2411   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2412   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2413   swig_callbackOnStyleChange = callbackOnStyleChange;
2414   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2415   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2416   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2417   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2418   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2419   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2420   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2421   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2422   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2423   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2424   swig_callbackOnPinch = callbackOnPinch;
2425   swig_callbackOnPan = callbackOnPan;
2426   swig_callbackOnTap = callbackOnTap;
2427   swig_callbackOnLongPress = callbackOnLongPress;
2428   swig_callbackSignalConnected = callbackSignalConnected;
2429   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2430 }
2431
2432 void SwigDirector_ViewImpl::swig_init_callbacks() {
2433   swig_callbackOnStageConnection = 0;
2434   swig_callbackOnStageDisconnection = 0;
2435   swig_callbackOnChildAdd = 0;
2436   swig_callbackOnChildRemove = 0;
2437   swig_callbackOnPropertySet = 0;
2438   swig_callbackOnSizeSet = 0;
2439   swig_callbackOnSizeAnimation = 0;
2440   swig_callbackOnTouchEvent = 0;
2441   swig_callbackOnHoverEvent = 0;
2442   swig_callbackOnKeyEvent = 0;
2443   swig_callbackOnWheelEvent = 0;
2444   swig_callbackOnRelayout = 0;
2445   swig_callbackOnSetResizePolicy = 0;
2446   swig_callbackGetNaturalSize = 0;
2447   swig_callbackCalculateChildSize = 0;
2448   swig_callbackGetHeightForWidth = 0;
2449   swig_callbackGetWidthForHeight = 0;
2450   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2451   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2452   swig_callbackOnCalculateRelayoutSize = 0;
2453   swig_callbackOnLayoutNegotiated = 0;
2454   swig_callbackOnInitialize = 0;
2455   swig_callbackOnControlChildAdd = 0;
2456   swig_callbackOnControlChildRemove = 0;
2457   swig_callbackOnStyleChange = 0;
2458   swig_callbackOnAccessibilityActivated = 0;
2459   swig_callbackOnAccessibilityPan = 0;
2460   swig_callbackOnAccessibilityTouch = 0;
2461   swig_callbackOnAccessibilityValueChange = 0;
2462   swig_callbackOnAccessibilityZoom = 0;
2463   swig_callbackOnKeyInputFocusGained = 0;
2464   swig_callbackOnKeyInputFocusLost = 0;
2465   swig_callbackGetNextKeyboardFocusableActor = 0;
2466   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2467   swig_callbackOnKeyboardEnter = 0;
2468   swig_callbackOnPinch = 0;
2469   swig_callbackOnPan = 0;
2470   swig_callbackOnTap = 0;
2471   swig_callbackOnLongPress = 0;
2472   swig_callbackSignalConnected = 0;
2473   swig_callbackSignalDisconnected = 0;
2474 }
2475
2476 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2477   swig_init_callbacks();
2478 }
2479
2480 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2481
2482 }
2483
2484
2485 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2486   unsigned int c_result = SwigValueInit< unsigned int >() ;
2487   unsigned int jresult = 0 ;
2488
2489   if (!swig_callbackGetNumberOfItems) {
2490     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2491   } else {
2492     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2493     c_result = (unsigned int)jresult;
2494   }
2495   return c_result;
2496 }
2497
2498 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2499   Dali::Actor c_result ;
2500   void * jresult = 0 ;
2501   unsigned int jitemId  ;
2502
2503   if (!swig_callbackNewItem) {
2504     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2505   } else {
2506     jitemId = itemId;
2507     jresult = (void *) swig_callbackNewItem(jitemId);
2508     if (!jresult) {
2509       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2510       return c_result;
2511     }
2512     c_result = *(Dali::Actor *)jresult;
2513   }
2514   return c_result;
2515 }
2516
2517 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2518   unsigned int jitemId  ;
2519   void * jactor  ;
2520
2521   if (!swig_callbackItemReleased) {
2522     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2523     return;
2524   } else {
2525     jitemId = itemId;
2526     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2527     swig_callbackItemReleased(jitemId, jactor);
2528   }
2529 }
2530
2531 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2532   return Dali::Toolkit::ItemFactory::GetExtension();
2533 }
2534
2535 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2536   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2537   swig_callbackNewItem = callbackNewItem;
2538   swig_callbackItemReleased = callbackItemReleased;
2539 }
2540
2541 void SwigDirector_ItemFactory::swig_init_callbacks() {
2542   swig_callbackGetNumberOfItems = 0;
2543   swig_callbackNewItem = 0;
2544   swig_callbackItemReleased = 0;
2545 }
2546
2547 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2548   swig_init_callbacks();
2549 }
2550
2551 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2552
2553 }
2554
2555
2556 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2557   Dali::Actor c_result ;
2558   void * jresult = 0 ;
2559   void * jcurrent  ;
2560   void * jproposed  ;
2561   int jdirection  ;
2562
2563   if (!swig_callbackGetNextFocusableActor) {
2564     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2565   } else {
2566     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2567     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2568     jdirection = (int)direction;
2569     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2570     if (!jresult) {
2571       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__);
2572       return c_result;
2573     }
2574     c_result = *(Dali::Actor *)jresult;
2575   }
2576   return c_result;
2577 }
2578
2579 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2580   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2581 }
2582
2583 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2584   swig_callbackGetNextFocusableActor = 0;
2585 }
2586
2587
2588 #ifdef __cplusplus
2589 extern "C" {
2590 #endif
2591
2592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2593   void * jresult ;
2594   floatp *result = 0 ;
2595
2596   {
2597     try {
2598       result = (floatp *)new_floatp();
2599     } catch (std::out_of_range& e) {
2600       {
2601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2602       };
2603     } catch (std::exception& e) {
2604       {
2605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2606       };
2607     } catch (DaliException e) {
2608       {
2609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2610       };
2611     } catch (...) {
2612       {
2613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2614       };
2615     }
2616   }
2617   jresult = (void *)result;
2618   return jresult;
2619 }
2620
2621
2622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2623   floatp *arg1 = (floatp *) 0 ;
2624
2625   arg1 = (floatp *)jarg1;
2626   {
2627     try {
2628       delete_floatp(arg1);
2629     } catch (std::out_of_range& e) {
2630       {
2631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2632       };
2633     } catch (std::exception& e) {
2634       {
2635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2636       };
2637     } catch (Dali::DaliException e) {
2638       {
2639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2640       };
2641     } catch (...) {
2642       {
2643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2644       };
2645     }
2646   }
2647
2648 }
2649
2650
2651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2652   floatp *arg1 = (floatp *) 0 ;
2653   float arg2 ;
2654
2655   arg1 = (floatp *)jarg1;
2656   arg2 = (float)jarg2;
2657   {
2658     try {
2659       floatp_assign(arg1,arg2);
2660     } catch (std::out_of_range& e) {
2661       {
2662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2663       };
2664     } catch (std::exception& e) {
2665       {
2666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2667       };
2668     } catch (Dali::DaliException e) {
2669       {
2670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2671       };
2672     } catch (...) {
2673       {
2674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2675       };
2676     }
2677   }
2678
2679 }
2680
2681
2682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2683   float jresult ;
2684   floatp *arg1 = (floatp *) 0 ;
2685   float result;
2686
2687   arg1 = (floatp *)jarg1;
2688   {
2689     try {
2690       result = (float)floatp_value(arg1);
2691     } catch (std::out_of_range& e) {
2692       {
2693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2694       };
2695     } catch (std::exception& e) {
2696       {
2697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2698       };
2699     } catch (DaliException e) {
2700       {
2701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2702       };
2703     } catch (...) {
2704       {
2705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2706       };
2707     }
2708   }
2709   jresult = result;
2710   return jresult;
2711 }
2712
2713
2714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2715   void * jresult ;
2716   floatp *arg1 = (floatp *) 0 ;
2717   float *result = 0 ;
2718
2719   arg1 = (floatp *)jarg1;
2720   {
2721     try {
2722       result = (float *)floatp_cast(arg1);
2723     } catch (std::out_of_range& e) {
2724       {
2725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2726       };
2727     } catch (std::exception& e) {
2728       {
2729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2730       };
2731     } catch (Dali::DaliException e) {
2732       {
2733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2734       };
2735     } catch (...) {
2736       {
2737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2738       };
2739     }
2740   }
2741
2742   jresult = (void *)result;
2743   return jresult;
2744 }
2745
2746
2747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2748   void * jresult ;
2749   float *arg1 = (float *) 0 ;
2750   floatp *result = 0 ;
2751
2752   arg1 = (float *)jarg1;
2753   {
2754     try {
2755       result = (floatp *)floatp_frompointer(arg1);
2756     } catch (std::out_of_range& e) {
2757       {
2758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2759       };
2760     } catch (std::exception& e) {
2761       {
2762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2763       };
2764     } catch (Dali::DaliException e) {
2765       {
2766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2767       };
2768     } catch (...) {
2769       {
2770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2771       };
2772     }
2773   }
2774
2775   jresult = (void *)result;
2776   return jresult;
2777 }
2778
2779
2780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2781   void * jresult ;
2782   intp *result = 0 ;
2783
2784   {
2785     try {
2786       result = (intp *)new_intp();
2787     } catch (std::out_of_range& e) {
2788       {
2789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (std::exception& e) {
2792       {
2793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2794       };
2795     } catch (Dali::DaliException e) {
2796       {
2797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2798       };
2799     } catch (...) {
2800       {
2801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2802       };
2803     }
2804   }
2805
2806   jresult = (void *)result;
2807   return jresult;
2808 }
2809
2810
2811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2812   intp *arg1 = (intp *) 0 ;
2813
2814   arg1 = (intp *)jarg1;
2815   {
2816     try {
2817       delete_intp(arg1);
2818     } catch (std::out_of_range& e) {
2819       {
2820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2821       };
2822     } catch (std::exception& e) {
2823       {
2824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2825       };
2826     } catch (Dali::DaliException e) {
2827       {
2828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2829       };
2830     } catch (...) {
2831       {
2832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2833       };
2834     }
2835   }
2836
2837 }
2838
2839
2840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2841   intp *arg1 = (intp *) 0 ;
2842   int arg2 ;
2843
2844   arg1 = (intp *)jarg1;
2845   arg2 = (int)jarg2;
2846   {
2847     try {
2848       intp_assign(arg1,arg2);
2849     } catch (std::out_of_range& e) {
2850       {
2851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2852       };
2853     } catch (std::exception& e) {
2854       {
2855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2856       };
2857     } catch (Dali::DaliException e) {
2858       {
2859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2860       };
2861     } catch (...) {
2862       {
2863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2864       };
2865     }
2866   }
2867
2868 }
2869
2870
2871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2872   int jresult ;
2873   intp *arg1 = (intp *) 0 ;
2874   int result;
2875
2876   arg1 = (intp *)jarg1;
2877   {
2878     try {
2879       result = (int)intp_value(arg1);
2880     } catch (std::out_of_range& e) {
2881       {
2882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2883       };
2884     } catch (std::exception& e) {
2885       {
2886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2887       };
2888     } catch (Dali::DaliException e) {
2889       {
2890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2891       };
2892     } catch (...) {
2893       {
2894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2895       };
2896     }
2897   }
2898
2899   jresult = result;
2900   return jresult;
2901 }
2902
2903
2904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2905   void * jresult ;
2906   intp *arg1 = (intp *) 0 ;
2907   int *result = 0 ;
2908
2909   arg1 = (intp *)jarg1;
2910   {
2911     try {
2912       result = (int *)intp_cast(arg1);
2913     } catch (std::out_of_range& e) {
2914       {
2915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2916       };
2917     } catch (std::exception& e) {
2918       {
2919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2920       };
2921     } catch (Dali::DaliException e) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2924       };
2925     } catch (...) {
2926       {
2927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2928       };
2929     }
2930   }
2931
2932   jresult = (void *)result;
2933   return jresult;
2934 }
2935
2936
2937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2938   void * jresult ;
2939   int *arg1 = (int *) 0 ;
2940   intp *result = 0 ;
2941
2942   arg1 = (int *)jarg1;
2943   {
2944     try {
2945       result = (intp *)intp_frompointer(arg1);
2946     } catch (std::out_of_range& e) {
2947       {
2948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2949       };
2950     } catch (std::exception& e) {
2951       {
2952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2953       };
2954     } catch (Dali::DaliException e) {
2955       {
2956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2957       };
2958     } catch (...) {
2959       {
2960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2961       };
2962     }
2963   }
2964
2965   jresult = (void *)result;
2966   return jresult;
2967 }
2968
2969
2970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2971   void * jresult ;
2972   doublep *result = 0 ;
2973
2974   {
2975     try {
2976       result = (doublep *)new_doublep();
2977     } catch (std::out_of_range& e) {
2978       {
2979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2980       };
2981     } catch (std::exception& e) {
2982       {
2983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2984       };
2985     } catch (Dali::DaliException e) {
2986       {
2987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2988       };
2989     } catch (...) {
2990       {
2991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2992       };
2993     }
2994   }
2995
2996   jresult = (void *)result;
2997   return jresult;
2998 }
2999
3000
3001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3002   doublep *arg1 = (doublep *) 0 ;
3003
3004   arg1 = (doublep *)jarg1;
3005   {
3006     try {
3007       delete_doublep(arg1);
3008     } catch (std::out_of_range& e) {
3009       {
3010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3011       };
3012     } catch (std::exception& e) {
3013       {
3014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3015       };
3016     } catch (Dali::DaliException e) {
3017       {
3018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3019       };
3020     } catch (...) {
3021       {
3022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3023       };
3024     }
3025   }
3026
3027 }
3028
3029
3030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3031   doublep *arg1 = (doublep *) 0 ;
3032   double arg2 ;
3033
3034   arg1 = (doublep *)jarg1;
3035   arg2 = (double)jarg2;
3036   {
3037     try {
3038       doublep_assign(arg1,arg2);
3039     } catch (std::out_of_range& e) {
3040       {
3041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3042       };
3043     } catch (std::exception& e) {
3044       {
3045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3046       };
3047     } catch (Dali::DaliException e) {
3048       {
3049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3050       };
3051     } catch (...) {
3052       {
3053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3054       };
3055     }
3056   }
3057
3058 }
3059
3060
3061 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3062   double jresult ;
3063   doublep *arg1 = (doublep *) 0 ;
3064   double result;
3065
3066   arg1 = (doublep *)jarg1;
3067   {
3068     try {
3069       result = (double)doublep_value(arg1);
3070     } catch (std::out_of_range& e) {
3071       {
3072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3073       };
3074     } catch (std::exception& e) {
3075       {
3076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3077       };
3078     } catch (Dali::DaliException e) {
3079       {
3080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3081       };
3082     } catch (...) {
3083       {
3084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3085       };
3086     }
3087   }
3088
3089   jresult = result;
3090   return jresult;
3091 }
3092
3093
3094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3095   void * jresult ;
3096   doublep *arg1 = (doublep *) 0 ;
3097   double *result = 0 ;
3098
3099   arg1 = (doublep *)jarg1;
3100   {
3101     try {
3102       result = (double *)doublep_cast(arg1);
3103     } catch (std::out_of_range& e) {
3104       {
3105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3106       };
3107     } catch (std::exception& e) {
3108       {
3109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3110       };
3111     } catch (Dali::DaliException e) {
3112       {
3113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3114       };
3115     } catch (...) {
3116       {
3117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3118       };
3119     }
3120   }
3121
3122   jresult = (void *)result;
3123   return jresult;
3124 }
3125
3126
3127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3128   void * jresult ;
3129   double *arg1 = (double *) 0 ;
3130   doublep *result = 0 ;
3131
3132   arg1 = (double *)jarg1;
3133   {
3134     try {
3135       result = (doublep *)doublep_frompointer(arg1);
3136     } catch (std::out_of_range& e) {
3137       {
3138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3139       };
3140     } catch (std::exception& e) {
3141       {
3142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3143       };
3144     } catch (Dali::DaliException e) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3147       };
3148     } catch (...) {
3149       {
3150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3151       };
3152     }
3153   }
3154
3155   jresult = (void *)result;
3156   return jresult;
3157 }
3158
3159
3160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3161   void * jresult ;
3162   uintp *result = 0 ;
3163
3164   {
3165     try {
3166       result = (uintp *)new_uintp();
3167     } catch (std::out_of_range& e) {
3168       {
3169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3170       };
3171     } catch (std::exception& e) {
3172       {
3173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3174       };
3175     } catch (Dali::DaliException e) {
3176       {
3177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3178       };
3179     } catch (...) {
3180       {
3181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3182       };
3183     }
3184   }
3185
3186   jresult = (void *)result;
3187   return jresult;
3188 }
3189
3190
3191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3192   uintp *arg1 = (uintp *) 0 ;
3193
3194   arg1 = (uintp *)jarg1;
3195   {
3196     try {
3197       delete_uintp(arg1);
3198     } catch (std::out_of_range& e) {
3199       {
3200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3201       };
3202     } catch (std::exception& e) {
3203       {
3204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3205       };
3206     } catch (Dali::DaliException e) {
3207       {
3208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3209       };
3210     } catch (...) {
3211       {
3212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3213       };
3214     }
3215   }
3216
3217 }
3218
3219
3220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3221   uintp *arg1 = (uintp *) 0 ;
3222   unsigned int arg2 ;
3223
3224   arg1 = (uintp *)jarg1;
3225   arg2 = (unsigned int)jarg2;
3226   {
3227     try {
3228       uintp_assign(arg1,arg2);
3229     } catch (std::out_of_range& e) {
3230       {
3231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3232       };
3233     } catch (std::exception& e) {
3234       {
3235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3236       };
3237     } catch (Dali::DaliException e) {
3238       {
3239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3240       };
3241     } catch (...) {
3242       {
3243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3244       };
3245     }
3246   }
3247
3248 }
3249
3250
3251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3252   unsigned int jresult ;
3253   uintp *arg1 = (uintp *) 0 ;
3254   unsigned int result;
3255
3256   arg1 = (uintp *)jarg1;
3257   {
3258     try {
3259       result = (unsigned int)uintp_value(arg1);
3260     } catch (std::out_of_range& e) {
3261       {
3262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3263       };
3264     } catch (std::exception& e) {
3265       {
3266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3267       };
3268     } catch (Dali::DaliException e) {
3269       {
3270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3271       };
3272     } catch (...) {
3273       {
3274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3275       };
3276     }
3277   }
3278
3279   jresult = result;
3280   return jresult;
3281 }
3282
3283
3284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3285   void * jresult ;
3286   uintp *arg1 = (uintp *) 0 ;
3287   unsigned int *result = 0 ;
3288
3289   arg1 = (uintp *)jarg1;
3290   {
3291     try {
3292       result = (unsigned int *)uintp_cast(arg1);
3293     } catch (std::out_of_range& e) {
3294       {
3295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (std::exception& e) {
3298       {
3299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3300       };
3301     } catch (Dali::DaliException e) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3304       };
3305     } catch (...) {
3306       {
3307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3308       };
3309     }
3310   }
3311
3312   jresult = (void *)result;
3313   return jresult;
3314 }
3315
3316
3317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3318   void * jresult ;
3319   unsigned int *arg1 = (unsigned int *) 0 ;
3320   uintp *result = 0 ;
3321
3322   arg1 = (unsigned int *)jarg1;
3323   {
3324     try {
3325       result = (uintp *)uintp_frompointer(arg1);
3326     } catch (std::out_of_range& e) {
3327       {
3328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3329       };
3330     } catch (std::exception& e) {
3331       {
3332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3333       };
3334     } catch (Dali::DaliException e) {
3335       {
3336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3337       };
3338     } catch (...) {
3339       {
3340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3341       };
3342     }
3343   }
3344
3345   jresult = (void *)result;
3346   return jresult;
3347 }
3348
3349
3350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3351   void * jresult ;
3352   ushortp *result = 0 ;
3353
3354   {
3355     try {
3356       result = (ushortp *)new_ushortp();
3357     } catch (std::out_of_range& e) {
3358       {
3359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3360       };
3361     } catch (std::exception& e) {
3362       {
3363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3364       };
3365     } catch (Dali::DaliException e) {
3366       {
3367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3368       };
3369     } catch (...) {
3370       {
3371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3372       };
3373     }
3374   }
3375
3376   jresult = (void *)result;
3377   return jresult;
3378 }
3379
3380
3381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3382   ushortp *arg1 = (ushortp *) 0 ;
3383
3384   arg1 = (ushortp *)jarg1;
3385   {
3386     try {
3387       delete_ushortp(arg1);
3388     } catch (std::out_of_range& e) {
3389       {
3390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3391       };
3392     } catch (std::exception& e) {
3393       {
3394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3395       };
3396     } catch (Dali::DaliException e) {
3397       {
3398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3399       };
3400     } catch (...) {
3401       {
3402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3403       };
3404     }
3405   }
3406
3407 }
3408
3409
3410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3411   ushortp *arg1 = (ushortp *) 0 ;
3412   unsigned short arg2 ;
3413
3414   arg1 = (ushortp *)jarg1;
3415   arg2 = (unsigned short)jarg2;
3416   {
3417     try {
3418       ushortp_assign(arg1,arg2);
3419     } catch (std::out_of_range& e) {
3420       {
3421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3422       };
3423     } catch (std::exception& e) {
3424       {
3425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3426       };
3427     } catch (Dali::DaliException e) {
3428       {
3429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3430       };
3431     } catch (...) {
3432       {
3433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3434       };
3435     }
3436   }
3437
3438 }
3439
3440
3441 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3442   unsigned short jresult ;
3443   ushortp *arg1 = (ushortp *) 0 ;
3444   unsigned short result;
3445
3446   arg1 = (ushortp *)jarg1;
3447   {
3448     try {
3449       result = (unsigned short)ushortp_value(arg1);
3450     } catch (std::out_of_range& e) {
3451       {
3452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3453       };
3454     } catch (std::exception& e) {
3455       {
3456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3457       };
3458     } catch (Dali::DaliException e) {
3459       {
3460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3461       };
3462     } catch (...) {
3463       {
3464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3465       };
3466     }
3467   }
3468
3469   jresult = result;
3470   return jresult;
3471 }
3472
3473
3474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3475   void * jresult ;
3476   ushortp *arg1 = (ushortp *) 0 ;
3477   unsigned short *result = 0 ;
3478
3479   arg1 = (ushortp *)jarg1;
3480   {
3481     try {
3482       result = (unsigned short *)ushortp_cast(arg1);
3483     } catch (std::out_of_range& e) {
3484       {
3485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3486       };
3487     } catch (std::exception& e) {
3488       {
3489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3490       };
3491     } catch (Dali::DaliException e) {
3492       {
3493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3494       };
3495     } catch (...) {
3496       {
3497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3498       };
3499     }
3500   }
3501
3502   jresult = (void *)result;
3503   return jresult;
3504 }
3505
3506
3507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3508   void * jresult ;
3509   unsigned short *arg1 = (unsigned short *) 0 ;
3510   ushortp *result = 0 ;
3511
3512   arg1 = (unsigned short *)jarg1;
3513   {
3514     try {
3515       result = (ushortp *)ushortp_frompointer(arg1);
3516     } catch (std::out_of_range& e) {
3517       {
3518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (std::exception& e) {
3521       {
3522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3523       };
3524     } catch (Dali::DaliException e) {
3525       {
3526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3527       };
3528     } catch (...) {
3529       {
3530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3531       };
3532     }
3533   }
3534
3535   jresult = (void *)result;
3536   return jresult;
3537 }
3538
3539
3540 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3541   unsigned int jresult ;
3542   int arg1 ;
3543   unsigned int result;
3544
3545   arg1 = (int)jarg1;
3546   {
3547     try {
3548       result = (unsigned int)int_to_uint(arg1);
3549     } catch (std::out_of_range& e) {
3550       {
3551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3552       };
3553     } catch (std::exception& e) {
3554       {
3555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3556       };
3557     } catch (Dali::DaliException e) {
3558       {
3559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3560       };
3561     } catch (...) {
3562       {
3563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3564       };
3565     }
3566   }
3567
3568   jresult = result;
3569   return jresult;
3570 }
3571
3572
3573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3574   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3575
3576   arg1 = (Dali::RefObject *)jarg1;
3577   {
3578     try {
3579       (arg1)->Reference();
3580     } catch (std::out_of_range& e) {
3581       {
3582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3583       };
3584     } catch (std::exception& e) {
3585       {
3586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3587       };
3588     } catch (Dali::DaliException e) {
3589       {
3590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3591       };
3592     } catch (...) {
3593       {
3594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3595       };
3596     }
3597   }
3598
3599 }
3600
3601
3602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3603   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3604
3605   arg1 = (Dali::RefObject *)jarg1;
3606   {
3607     try {
3608       (arg1)->Unreference();
3609     } catch (std::out_of_range& e) {
3610       {
3611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3612       };
3613     } catch (std::exception& e) {
3614       {
3615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3616       };
3617     } catch (Dali::DaliException e) {
3618       {
3619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3620       };
3621     } catch (...) {
3622       {
3623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3624       };
3625     }
3626   }
3627
3628 }
3629
3630
3631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3632   int jresult ;
3633   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3634   int result;
3635
3636   arg1 = (Dali::RefObject *)jarg1;
3637   {
3638     try {
3639       result = (int)(arg1)->ReferenceCount();
3640     } catch (std::out_of_range& e) {
3641       {
3642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3643       };
3644     } catch (std::exception& e) {
3645       {
3646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3647       };
3648     } catch (Dali::DaliException e) {
3649       {
3650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3651       };
3652     } catch (...) {
3653       {
3654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3655       };
3656     }
3657   }
3658
3659   jresult = result;
3660   return jresult;
3661 }
3662
3663
3664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3665   void * jresult ;
3666   Dali::Any *result = 0 ;
3667
3668   {
3669     try {
3670       result = (Dali::Any *)new Dali::Any();
3671     } catch (std::out_of_range& e) {
3672       {
3673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3674       };
3675     } catch (std::exception& e) {
3676       {
3677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3678       };
3679     } catch (Dali::DaliException e) {
3680       {
3681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3682       };
3683     } catch (...) {
3684       {
3685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3686       };
3687     }
3688   }
3689
3690   jresult = (void *)result;
3691   return jresult;
3692 }
3693
3694
3695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3696   Dali::Any *arg1 = (Dali::Any *) 0 ;
3697
3698   arg1 = (Dali::Any *)jarg1;
3699   {
3700     try {
3701       delete arg1;
3702     } catch (std::out_of_range& e) {
3703       {
3704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3705       };
3706     } catch (std::exception& e) {
3707       {
3708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3709       };
3710     } catch (Dali::DaliException e) {
3711       {
3712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3713       };
3714     } catch (...) {
3715       {
3716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3717       };
3718     }
3719   }
3720
3721 }
3722
3723
3724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3725   char *arg1 = (char *) 0 ;
3726
3727   arg1 = (char *)jarg1;
3728   {
3729     try {
3730       Dali::Any::AssertAlways((char const *)arg1);
3731     } catch (std::out_of_range& e) {
3732       {
3733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3734       };
3735     } catch (std::exception& e) {
3736       {
3737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3738       };
3739     } catch (Dali::DaliException e) {
3740       {
3741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3742       };
3743     } catch (...) {
3744       {
3745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3746       };
3747     }
3748   }
3749
3750 }
3751
3752
3753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3754   void * jresult ;
3755   Dali::Any *arg1 = 0 ;
3756   Dali::Any *result = 0 ;
3757
3758   arg1 = (Dali::Any *)jarg1;
3759   if (!arg1) {
3760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3761     return 0;
3762   }
3763   {
3764     try {
3765       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3766     } catch (std::out_of_range& e) {
3767       {
3768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3769       };
3770     } catch (std::exception& e) {
3771       {
3772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3773       };
3774     } catch (Dali::DaliException e) {
3775       {
3776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3777       };
3778     } catch (...) {
3779       {
3780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3781       };
3782     }
3783   }
3784
3785   jresult = (void *)result;
3786   return jresult;
3787 }
3788
3789
3790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3791   void * jresult ;
3792   Dali::Any *arg1 = (Dali::Any *) 0 ;
3793   Dali::Any *arg2 = 0 ;
3794   Dali::Any *result = 0 ;
3795
3796   arg1 = (Dali::Any *)jarg1;
3797   arg2 = (Dali::Any *)jarg2;
3798   if (!arg2) {
3799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3800     return 0;
3801   }
3802   {
3803     try {
3804       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3805     } catch (std::out_of_range& e) {
3806       {
3807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3808       };
3809     } catch (std::exception& e) {
3810       {
3811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3812       };
3813     } catch (Dali::DaliException e) {
3814       {
3815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3816       };
3817     } catch (...) {
3818       {
3819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3820       };
3821     }
3822   }
3823
3824   jresult = (void *)result;
3825   return jresult;
3826 }
3827
3828
3829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3830   void * jresult ;
3831   Dali::Any *arg1 = (Dali::Any *) 0 ;
3832   std::type_info *result = 0 ;
3833
3834   arg1 = (Dali::Any *)jarg1;
3835   {
3836     try {
3837       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3838     } catch (std::out_of_range& e) {
3839       {
3840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3841       };
3842     } catch (std::exception& e) {
3843       {
3844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3845       };
3846     } catch (Dali::DaliException e) {
3847       {
3848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3849       };
3850     } catch (...) {
3851       {
3852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3853       };
3854     }
3855   }
3856
3857   jresult = (void *)result;
3858   return jresult;
3859 }
3860
3861
3862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3863   unsigned int jresult ;
3864   Dali::Any *arg1 = (Dali::Any *) 0 ;
3865   bool result;
3866
3867   arg1 = (Dali::Any *)jarg1;
3868   {
3869     try {
3870       result = (bool)((Dali::Any const *)arg1)->Empty();
3871     } catch (std::out_of_range& e) {
3872       {
3873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3874       };
3875     } catch (std::exception& e) {
3876       {
3877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3878       };
3879     } catch (Dali::DaliException e) {
3880       {
3881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3882       };
3883     } catch (...) {
3884       {
3885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3886       };
3887     }
3888   }
3889
3890   jresult = result;
3891   return jresult;
3892 }
3893
3894
3895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3896   void * jresult ;
3897   std::type_info *arg1 = 0 ;
3898   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3899   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3900   Dali::Any::AnyContainerBase *result = 0 ;
3901
3902   arg1 = (std::type_info *)jarg1;
3903   if (!arg1) {
3904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3905     return 0;
3906   }
3907   arg2 = (Dali::Any::CloneFunc)jarg2;
3908   arg3 = (Dali::Any::DeleteFunc)jarg3;
3909   {
3910     try {
3911       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3912     } catch (std::out_of_range& e) {
3913       {
3914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3915       };
3916     } catch (std::exception& e) {
3917       {
3918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3919       };
3920     } catch (Dali::DaliException e) {
3921       {
3922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3923       };
3924     } catch (...) {
3925       {
3926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3927       };
3928     }
3929   }
3930
3931   jresult = (void *)result;
3932   return jresult;
3933 }
3934
3935
3936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3937   void * jresult ;
3938   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3939   std::type_info *result = 0 ;
3940
3941   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3942   {
3943     try {
3944       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3945     } catch (std::out_of_range& e) {
3946       {
3947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3948       };
3949     } catch (std::exception& e) {
3950       {
3951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3952       };
3953     } catch (Dali::DaliException e) {
3954       {
3955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3956       };
3957     } catch (...) {
3958       {
3959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3960       };
3961     }
3962   }
3963
3964   jresult = (void *)result;
3965   return jresult;
3966 }
3967
3968
3969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3970   void * jresult ;
3971   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3972   ::std::type_info *result = 0 ;
3973
3974   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3975   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3976   jresult = (void *)result;
3977   return jresult;
3978 }
3979
3980
3981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3982   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3983   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3984
3985   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3986   arg2 = (Dali::Any::CloneFunc)jarg2;
3987   if (arg1) (arg1)->mCloneFunc = arg2;
3988 }
3989
3990
3991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3992   void * jresult ;
3993   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3994   Dali::Any::CloneFunc result;
3995
3996   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3997   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3998   jresult = (void *)result;
3999   return jresult;
4000 }
4001
4002
4003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4004   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4005   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4006
4007   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4008   arg2 = (Dali::Any::DeleteFunc)jarg2;
4009   if (arg1) (arg1)->mDeleteFunc = arg2;
4010 }
4011
4012
4013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4014   void * jresult ;
4015   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4016   Dali::Any::DeleteFunc result;
4017
4018   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4019   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4020   jresult = (void *)result;
4021   return jresult;
4022 }
4023
4024
4025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4026   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4027
4028   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4029   {
4030     try {
4031       delete arg1;
4032     } catch (std::out_of_range& e) {
4033       {
4034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4035       };
4036     } catch (std::exception& e) {
4037       {
4038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4039       };
4040     } catch (Dali::DaliException e) {
4041       {
4042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4043       };
4044     } catch (...) {
4045       {
4046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4047       };
4048     }
4049   }
4050
4051 }
4052
4053
4054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4055   Dali::Any *arg1 = (Dali::Any *) 0 ;
4056   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4057
4058   arg1 = (Dali::Any *)jarg1;
4059   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4060   if (arg1) (arg1)->mContainer = arg2;
4061 }
4062
4063
4064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4065   void * jresult ;
4066   Dali::Any *arg1 = (Dali::Any *) 0 ;
4067   Dali::Any::AnyContainerBase *result = 0 ;
4068
4069   arg1 = (Dali::Any *)jarg1;
4070   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4071   jresult = (void *)result;
4072   return jresult;
4073 }
4074
4075
4076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4077   char *arg1 = (char *) 0 ;
4078   char *arg2 = (char *) 0 ;
4079
4080   arg1 = (char *)jarg1;
4081   arg2 = (char *)jarg2;
4082   {
4083     try {
4084       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4085     } catch (std::out_of_range& e) {
4086       {
4087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4088       };
4089     } catch (std::exception& e) {
4090       {
4091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4092       };
4093     } catch (Dali::DaliException e) {
4094       {
4095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4096       };
4097     } catch (...) {
4098       {
4099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4100       };
4101     }
4102   }
4103
4104 }
4105
4106
4107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4108   void * jresult ;
4109   char *arg1 = (char *) 0 ;
4110   char *arg2 = (char *) 0 ;
4111   Dali::DaliException *result = 0 ;
4112
4113   arg1 = (char *)jarg1;
4114   arg2 = (char *)jarg2;
4115   {
4116     try {
4117       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4118     } catch (std::out_of_range& e) {
4119       {
4120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4121       };
4122     } catch (std::exception& e) {
4123       {
4124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4125       };
4126     } catch (Dali::DaliException e) {
4127       {
4128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4129       };
4130     } catch (...) {
4131       {
4132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4133       };
4134     }
4135   }
4136
4137   jresult = (void *)result;
4138   return jresult;
4139 }
4140
4141
4142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4143   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4144   std::string arg2 = std::string(jarg2);
4145
4146   arg1 = (Dali::DaliException *)jarg1;
4147   {
4148     if (!arg2.empty()) {
4149       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4150     } else {
4151       arg1->location = 0;
4152     }
4153   }
4154 }
4155
4156 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4157   char * jresult ;
4158   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4159   char *result = 0 ;
4160
4161   arg1 = (Dali::DaliException *)jarg1;
4162   result = (char *) ((arg1)->location);
4163   jresult = SWIG_csharp_string_callback((const char *)result);
4164   return jresult;
4165 }
4166
4167
4168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4169   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4170   std::string arg2 = std::string(jarg2);
4171
4172   arg1 = (Dali::DaliException *)jarg1;
4173   {
4174     if (!arg2.empty()) {
4175       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4176     } else {
4177       arg1->condition = 0;
4178     }
4179   }
4180 }
4181
4182
4183 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4184   char * jresult ;
4185   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4186   char *result = 0 ;
4187
4188   arg1 = (Dali::DaliException *)jarg1;
4189   result = (char *) ((arg1)->condition);
4190   jresult = SWIG_csharp_string_callback((const char *)result);
4191   return jresult;
4192 }
4193
4194
4195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4196   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4197
4198   arg1 = (Dali::DaliException *)jarg1;
4199   {
4200     try {
4201       delete arg1;
4202     } catch (std::out_of_range& e) {
4203       {
4204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4205       };
4206     } catch (std::exception& e) {
4207       {
4208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4209       };
4210     } catch (Dali::DaliException e) {
4211       {
4212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4213       };
4214     } catch (...) {
4215       {
4216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4217       };
4218     }
4219   }
4220
4221 }
4222
4223
4224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4225   void * jresult ;
4226   Dali::Vector2 *result = 0 ;
4227
4228   {
4229     try {
4230       result = (Dali::Vector2 *)new Dali::Vector2();
4231     } catch (std::out_of_range& e) {
4232       {
4233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4234       };
4235     } catch (std::exception& e) {
4236       {
4237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4238       };
4239     } catch (Dali::DaliException e) {
4240       {
4241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4242       };
4243     } catch (...) {
4244       {
4245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4246       };
4247     }
4248   }
4249
4250   jresult = (void *)result;
4251   return jresult;
4252 }
4253
4254
4255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4256   void * jresult ;
4257   float arg1 ;
4258   float arg2 ;
4259   Dali::Vector2 *result = 0 ;
4260
4261   arg1 = (float)jarg1;
4262   arg2 = (float)jarg2;
4263   {
4264     try {
4265       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4266     } catch (std::out_of_range& e) {
4267       {
4268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4269       };
4270     } catch (std::exception& e) {
4271       {
4272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4273       };
4274     } catch (Dali::DaliException e) {
4275       {
4276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4277       };
4278     } catch (...) {
4279       {
4280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4281       };
4282     }
4283   }
4284
4285   jresult = (void *)result;
4286   return jresult;
4287 }
4288
4289
4290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4291   void * jresult ;
4292   float *arg1 = (float *) 0 ;
4293   Dali::Vector2 *result = 0 ;
4294
4295   arg1 = jarg1;
4296   {
4297     try {
4298       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4299     } catch (std::out_of_range& e) {
4300       {
4301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4302       };
4303     } catch (std::exception& e) {
4304       {
4305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4306       };
4307     } catch (Dali::DaliException e) {
4308       {
4309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4310       };
4311     } catch (...) {
4312       {
4313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4314       };
4315     }
4316   }
4317
4318   jresult = (void *)result;
4319
4320
4321   return jresult;
4322 }
4323
4324
4325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4326   void * jresult ;
4327   Dali::Vector3 *arg1 = 0 ;
4328   Dali::Vector2 *result = 0 ;
4329
4330   arg1 = (Dali::Vector3 *)jarg1;
4331   if (!arg1) {
4332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4333     return 0;
4334   }
4335   {
4336     try {
4337       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4338     } catch (std::out_of_range& e) {
4339       {
4340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4341       };
4342     } catch (std::exception& e) {
4343       {
4344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4345       };
4346     } catch (Dali::DaliException e) {
4347       {
4348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4349       };
4350     } catch (...) {
4351       {
4352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4353       };
4354     }
4355   }
4356
4357   jresult = (void *)result;
4358   return jresult;
4359 }
4360
4361
4362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4363   void * jresult ;
4364   Dali::Vector4 *arg1 = 0 ;
4365   Dali::Vector2 *result = 0 ;
4366
4367   arg1 = (Dali::Vector4 *)jarg1;
4368   if (!arg1) {
4369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4370     return 0;
4371   }
4372   {
4373     try {
4374       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4375     } catch (std::out_of_range& e) {
4376       {
4377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4378       };
4379     } catch (std::exception& e) {
4380       {
4381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4382       };
4383     } catch (Dali::DaliException e) {
4384       {
4385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4386       };
4387     } catch (...) {
4388       {
4389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4390       };
4391     }
4392   }
4393
4394   jresult = (void *)result;
4395   return jresult;
4396 }
4397
4398
4399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4400   void * jresult ;
4401   Dali::Vector2 *result = 0 ;
4402
4403   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4404   jresult = (void *)result;
4405   return jresult;
4406 }
4407
4408
4409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4410   void * jresult ;
4411   Dali::Vector2 *result = 0 ;
4412
4413   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4414   jresult = (void *)result;
4415   return jresult;
4416 }
4417
4418
4419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4420   void * jresult ;
4421   Dali::Vector2 *result = 0 ;
4422
4423   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4424   jresult = (void *)result;
4425   return jresult;
4426 }
4427
4428
4429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4430   void * jresult ;
4431   Dali::Vector2 *result = 0 ;
4432
4433   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4434   jresult = (void *)result;
4435   return jresult;
4436 }
4437
4438
4439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4440   void * jresult ;
4441   Dali::Vector2 *result = 0 ;
4442
4443   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4444   jresult = (void *)result;
4445   return jresult;
4446 }
4447
4448
4449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4450   void * jresult ;
4451   Dali::Vector2 *result = 0 ;
4452
4453   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4454   jresult = (void *)result;
4455   return jresult;
4456 }
4457
4458
4459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4460   void * jresult ;
4461   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4462   float *arg2 = (float *) 0 ;
4463   Dali::Vector2 *result = 0 ;
4464
4465   arg1 = (Dali::Vector2 *)jarg1;
4466   arg2 = jarg2;
4467   {
4468     try {
4469       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4470     } catch (std::out_of_range& e) {
4471       {
4472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4473       };
4474     } catch (std::exception& e) {
4475       {
4476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4477       };
4478     } catch (Dali::DaliException e) {
4479       {
4480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4481       };
4482     } catch (...) {
4483       {
4484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4485       };
4486     }
4487   }
4488
4489   jresult = (void *)result;
4490
4491
4492   return jresult;
4493 }
4494
4495
4496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4497   void * jresult ;
4498   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4499   Dali::Vector3 *arg2 = 0 ;
4500   Dali::Vector2 *result = 0 ;
4501
4502   arg1 = (Dali::Vector2 *)jarg1;
4503   arg2 = (Dali::Vector3 *)jarg2;
4504   if (!arg2) {
4505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4506     return 0;
4507   }
4508   {
4509     try {
4510       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4511     } catch (std::out_of_range& e) {
4512       {
4513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4514       };
4515     } catch (std::exception& e) {
4516       {
4517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4518       };
4519     } catch (Dali::DaliException e) {
4520       {
4521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4522       };
4523     } catch (...) {
4524       {
4525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4526       };
4527     }
4528   }
4529
4530   jresult = (void *)result;
4531   return jresult;
4532 }
4533
4534
4535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4536   void * jresult ;
4537   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4538   Dali::Vector4 *arg2 = 0 ;
4539   Dali::Vector2 *result = 0 ;
4540
4541   arg1 = (Dali::Vector2 *)jarg1;
4542   arg2 = (Dali::Vector4 *)jarg2;
4543   if (!arg2) {
4544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4545     return 0;
4546   }
4547   {
4548     try {
4549       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4550     } catch (std::out_of_range& e) {
4551       {
4552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4553       };
4554     } catch (std::exception& e) {
4555       {
4556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4557       };
4558     } catch (Dali::DaliException e) {
4559       {
4560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4561       };
4562     } catch (...) {
4563       {
4564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4565       };
4566     }
4567   }
4568
4569   jresult = (void *)result;
4570   return jresult;
4571 }
4572
4573
4574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4575   void * jresult ;
4576   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4577   Dali::Vector2 *arg2 = 0 ;
4578   Dali::Vector2 result;
4579
4580   arg1 = (Dali::Vector2 *)jarg1;
4581   arg2 = (Dali::Vector2 *)jarg2;
4582   if (!arg2) {
4583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4584     return 0;
4585   }
4586   {
4587     try {
4588       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4589     } catch (std::out_of_range& e) {
4590       {
4591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4592       };
4593     } catch (std::exception& e) {
4594       {
4595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4596       };
4597     } catch (Dali::DaliException e) {
4598       {
4599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4600       };
4601     } catch (...) {
4602       {
4603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4604       };
4605     }
4606   }
4607
4608   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4609   return jresult;
4610 }
4611
4612
4613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4614   void * jresult ;
4615   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4616   Dali::Vector2 *arg2 = 0 ;
4617   Dali::Vector2 *result = 0 ;
4618
4619   arg1 = (Dali::Vector2 *)jarg1;
4620   arg2 = (Dali::Vector2 *)jarg2;
4621   if (!arg2) {
4622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4623     return 0;
4624   }
4625   {
4626     try {
4627       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4628     } catch (std::out_of_range& e) {
4629       {
4630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4631       };
4632     } catch (std::exception& e) {
4633       {
4634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4635       };
4636     } catch (Dali::DaliException e) {
4637       {
4638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4639       };
4640     } catch (...) {
4641       {
4642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4643       };
4644     }
4645   }
4646
4647   jresult = (void *)result;
4648   return jresult;
4649 }
4650
4651
4652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4653   void * jresult ;
4654   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4655   Dali::Vector2 *arg2 = 0 ;
4656   Dali::Vector2 result;
4657
4658   arg1 = (Dali::Vector2 *)jarg1;
4659   arg2 = (Dali::Vector2 *)jarg2;
4660   if (!arg2) {
4661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4662     return 0;
4663   }
4664   {
4665     try {
4666       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4667     } catch (std::out_of_range& e) {
4668       {
4669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4670       };
4671     } catch (std::exception& e) {
4672       {
4673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4674       };
4675     } catch (Dali::DaliException e) {
4676       {
4677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4678       };
4679     } catch (...) {
4680       {
4681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4682       };
4683     }
4684   }
4685
4686   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4687   return jresult;
4688 }
4689
4690
4691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4692   void * jresult ;
4693   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4694   Dali::Vector2 *arg2 = 0 ;
4695   Dali::Vector2 *result = 0 ;
4696
4697   arg1 = (Dali::Vector2 *)jarg1;
4698   arg2 = (Dali::Vector2 *)jarg2;
4699   if (!arg2) {
4700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4701     return 0;
4702   }
4703   {
4704     try {
4705       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4706     } catch (std::out_of_range& e) {
4707       {
4708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4709       };
4710     } catch (std::exception& e) {
4711       {
4712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4713       };
4714     } catch (Dali::DaliException e) {
4715       {
4716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4717       };
4718     } catch (...) {
4719       {
4720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4721       };
4722     }
4723   }
4724
4725   jresult = (void *)result;
4726   return jresult;
4727 }
4728
4729
4730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4731   void * jresult ;
4732   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4733   Dali::Vector2 *arg2 = 0 ;
4734   Dali::Vector2 result;
4735
4736   arg1 = (Dali::Vector2 *)jarg1;
4737   arg2 = (Dali::Vector2 *)jarg2;
4738   if (!arg2) {
4739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4740     return 0;
4741   }
4742   {
4743     try {
4744       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4745     } catch (std::out_of_range& e) {
4746       {
4747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4748       };
4749     } catch (std::exception& e) {
4750       {
4751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4752       };
4753     } catch (Dali::DaliException e) {
4754       {
4755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4756       };
4757     } catch (...) {
4758       {
4759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4760       };
4761     }
4762   }
4763
4764   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4765   return jresult;
4766 }
4767
4768
4769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4770   void * jresult ;
4771   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4772   float arg2 ;
4773   Dali::Vector2 result;
4774
4775   arg1 = (Dali::Vector2 *)jarg1;
4776   arg2 = (float)jarg2;
4777   {
4778     try {
4779       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4780     } catch (std::out_of_range& e) {
4781       {
4782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4783       };
4784     } catch (std::exception& e) {
4785       {
4786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4787       };
4788     } catch (Dali::DaliException e) {
4789       {
4790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4791       };
4792     } catch (...) {
4793       {
4794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4795       };
4796     }
4797   }
4798
4799   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4800   return jresult;
4801 }
4802
4803
4804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4805   void * jresult ;
4806   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4807   Dali::Vector2 *arg2 = 0 ;
4808   Dali::Vector2 *result = 0 ;
4809
4810   arg1 = (Dali::Vector2 *)jarg1;
4811   arg2 = (Dali::Vector2 *)jarg2;
4812   if (!arg2) {
4813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4814     return 0;
4815   }
4816   {
4817     try {
4818       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4819     } catch (std::out_of_range& e) {
4820       {
4821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4822       };
4823     } catch (std::exception& e) {
4824       {
4825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4826       };
4827     } catch (Dali::DaliException e) {
4828       {
4829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4830       };
4831     } catch (...) {
4832       {
4833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4834       };
4835     }
4836   }
4837
4838   jresult = (void *)result;
4839   return jresult;
4840 }
4841
4842
4843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4844   void * jresult ;
4845   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4846   float arg2 ;
4847   Dali::Vector2 *result = 0 ;
4848
4849   arg1 = (Dali::Vector2 *)jarg1;
4850   arg2 = (float)jarg2;
4851   {
4852     try {
4853       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4854     } catch (std::out_of_range& e) {
4855       {
4856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4857       };
4858     } catch (std::exception& e) {
4859       {
4860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4861       };
4862     } catch (Dali::DaliException e) {
4863       {
4864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4865       };
4866     } catch (...) {
4867       {
4868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4869       };
4870     }
4871   }
4872
4873   jresult = (void *)result;
4874   return jresult;
4875 }
4876
4877
4878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4879   void * jresult ;
4880   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4881   Dali::Vector2 *arg2 = 0 ;
4882   Dali::Vector2 result;
4883
4884   arg1 = (Dali::Vector2 *)jarg1;
4885   arg2 = (Dali::Vector2 *)jarg2;
4886   if (!arg2) {
4887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4888     return 0;
4889   }
4890   {
4891     try {
4892       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4893     } catch (std::out_of_range& e) {
4894       {
4895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4896       };
4897     } catch (std::exception& e) {
4898       {
4899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4900       };
4901     } catch (Dali::DaliException e) {
4902       {
4903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4904       };
4905     } catch (...) {
4906       {
4907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4908       };
4909     }
4910   }
4911
4912   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4913   return jresult;
4914 }
4915
4916
4917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4918   void * jresult ;
4919   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4920   float arg2 ;
4921   Dali::Vector2 result;
4922
4923   arg1 = (Dali::Vector2 *)jarg1;
4924   arg2 = (float)jarg2;
4925   {
4926     try {
4927       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4928     } catch (std::out_of_range& e) {
4929       {
4930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4931       };
4932     } catch (std::exception& e) {
4933       {
4934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4935       };
4936     } catch (Dali::DaliException e) {
4937       {
4938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4939       };
4940     } catch (...) {
4941       {
4942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4943       };
4944     }
4945   }
4946
4947   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4948   return jresult;
4949 }
4950
4951
4952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4953   void * jresult ;
4954   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4955   Dali::Vector2 *arg2 = 0 ;
4956   Dali::Vector2 *result = 0 ;
4957
4958   arg1 = (Dali::Vector2 *)jarg1;
4959   arg2 = (Dali::Vector2 *)jarg2;
4960   if (!arg2) {
4961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4962     return 0;
4963   }
4964   {
4965     try {
4966       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4967     } catch (std::out_of_range& e) {
4968       {
4969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4970       };
4971     } catch (std::exception& e) {
4972       {
4973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4974       };
4975     } catch (Dali::DaliException e) {
4976       {
4977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4978       };
4979     } catch (...) {
4980       {
4981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4982       };
4983     }
4984   }
4985
4986   jresult = (void *)result;
4987   return jresult;
4988 }
4989
4990
4991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4992   void * jresult ;
4993   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4994   float arg2 ;
4995   Dali::Vector2 *result = 0 ;
4996
4997   arg1 = (Dali::Vector2 *)jarg1;
4998   arg2 = (float)jarg2;
4999   {
5000     try {
5001       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5002     } catch (std::out_of_range& e) {
5003       {
5004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5005       };
5006     } catch (std::exception& e) {
5007       {
5008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5009       };
5010     } catch (Dali::DaliException e) {
5011       {
5012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5013       };
5014     } catch (...) {
5015       {
5016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5017       };
5018     }
5019   }
5020
5021   jresult = (void *)result;
5022   return jresult;
5023 }
5024
5025
5026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5027   void * jresult ;
5028   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5029   Dali::Vector2 result;
5030
5031   arg1 = (Dali::Vector2 *)jarg1;
5032   {
5033     try {
5034       result = ((Dali::Vector2 const *)arg1)->operator -();
5035     } catch (std::out_of_range& e) {
5036       {
5037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5038       };
5039     } catch (std::exception& e) {
5040       {
5041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5042       };
5043     } catch (Dali::DaliException e) {
5044       {
5045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5046       };
5047     } catch (...) {
5048       {
5049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5050       };
5051     }
5052   }
5053
5054   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5055   return jresult;
5056 }
5057
5058
5059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5060   unsigned int jresult ;
5061   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5062   Dali::Vector2 *arg2 = 0 ;
5063   bool result;
5064
5065   arg1 = (Dali::Vector2 *)jarg1;
5066   arg2 = (Dali::Vector2 *)jarg2;
5067   if (!arg2) {
5068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5069     return 0;
5070   }
5071   {
5072     try {
5073       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5074     } catch (std::out_of_range& e) {
5075       {
5076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (std::exception& e) {
5079       {
5080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5081       };
5082     } catch (Dali::DaliException e) {
5083       {
5084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5085       };
5086     } catch (...) {
5087       {
5088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5089       };
5090     }
5091   }
5092
5093   jresult = result;
5094   return jresult;
5095 }
5096
5097
5098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5099   unsigned int jresult ;
5100   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5101   Dali::Vector2 *arg2 = 0 ;
5102   bool result;
5103
5104   arg1 = (Dali::Vector2 *)jarg1;
5105   arg2 = (Dali::Vector2 *)jarg2;
5106   if (!arg2) {
5107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5108     return 0;
5109   }
5110   {
5111     try {
5112       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5113     } catch (std::out_of_range& e) {
5114       {
5115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5116       };
5117     } catch (std::exception& e) {
5118       {
5119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5120       };
5121     } catch (Dali::DaliException e) {
5122       {
5123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5124       };
5125     } catch (...) {
5126       {
5127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5128       };
5129     }
5130   }
5131
5132   jresult = result;
5133   return jresult;
5134 }
5135
5136
5137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5138   float jresult ;
5139   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5140   unsigned int arg2 ;
5141   float *result = 0 ;
5142
5143   arg1 = (Dali::Vector2 *)jarg1;
5144   arg2 = (unsigned int)jarg2;
5145   {
5146     try {
5147       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5148     } catch (std::out_of_range& e) {
5149       {
5150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5151       };
5152     } catch (std::exception& e) {
5153       {
5154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5155       };
5156     } catch (Dali::DaliException e) {
5157       {
5158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5159       };
5160     } catch (...) {
5161       {
5162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5163       };
5164     }
5165   }
5166
5167   jresult = *result;
5168   return jresult;
5169 }
5170
5171
5172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5173   float jresult ;
5174   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5175   float result;
5176
5177   arg1 = (Dali::Vector2 *)jarg1;
5178   {
5179     try {
5180       result = (float)((Dali::Vector2 const *)arg1)->Length();
5181     } catch (std::out_of_range& e) {
5182       {
5183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5184       };
5185     } catch (std::exception& e) {
5186       {
5187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5188       };
5189     } catch (Dali::DaliException e) {
5190       {
5191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5192       };
5193     } catch (...) {
5194       {
5195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5196       };
5197     }
5198   }
5199
5200   jresult = result;
5201   return jresult;
5202 }
5203
5204
5205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5206   float jresult ;
5207   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5208   float result;
5209
5210   arg1 = (Dali::Vector2 *)jarg1;
5211   {
5212     try {
5213       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5214     } catch (std::out_of_range& e) {
5215       {
5216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5217       };
5218     } catch (std::exception& e) {
5219       {
5220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5221       };
5222     } catch (Dali::DaliException e) {
5223       {
5224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5225       };
5226     } catch (...) {
5227       {
5228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5229       };
5230     }
5231   }
5232
5233   jresult = result;
5234   return jresult;
5235 }
5236
5237
5238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5239   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5240
5241   arg1 = (Dali::Vector2 *)jarg1;
5242   {
5243     try {
5244       (arg1)->Normalize();
5245     } catch (std::out_of_range& e) {
5246       {
5247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5248       };
5249     } catch (std::exception& e) {
5250       {
5251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5252       };
5253     } catch (Dali::DaliException e) {
5254       {
5255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5256       };
5257     } catch (...) {
5258       {
5259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5260       };
5261     }
5262   }
5263
5264 }
5265
5266
5267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5268   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5269   Dali::Vector2 *arg2 = 0 ;
5270   Dali::Vector2 *arg3 = 0 ;
5271
5272   arg1 = (Dali::Vector2 *)jarg1;
5273   arg2 = (Dali::Vector2 *)jarg2;
5274   if (!arg2) {
5275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5276     return ;
5277   }
5278   arg3 = (Dali::Vector2 *)jarg3;
5279   if (!arg3) {
5280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5281     return ;
5282   }
5283   {
5284     try {
5285       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5286     } catch (std::out_of_range& e) {
5287       {
5288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5289       };
5290     } catch (std::exception& e) {
5291       {
5292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5293       };
5294     } catch (Dali::DaliException e) {
5295       {
5296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5297       };
5298     } catch (...) {
5299       {
5300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5301       };
5302     }
5303   }
5304
5305 }
5306
5307
5308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5309   void * jresult ;
5310   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5311   float *result = 0 ;
5312
5313   arg1 = (Dali::Vector2 *)jarg1;
5314   {
5315     try {
5316       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5317     } catch (std::out_of_range& e) {
5318       {
5319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5320       };
5321     } catch (std::exception& e) {
5322       {
5323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5324       };
5325     } catch (Dali::DaliException e) {
5326       {
5327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5328       };
5329     } catch (...) {
5330       {
5331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5332       };
5333     }
5334   }
5335
5336   jresult = (void *)result;
5337   return jresult;
5338 }
5339
5340
5341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5342   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5343   float arg2 ;
5344
5345   arg1 = (Dali::Vector2 *)jarg1;
5346   arg2 = (float)jarg2;
5347   if (arg1) (arg1)->x = arg2;
5348 }
5349
5350
5351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5352   float jresult ;
5353   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5354   float result;
5355
5356   arg1 = (Dali::Vector2 *)jarg1;
5357   result = (float) ((arg1)->x);
5358   jresult = result;
5359   return jresult;
5360 }
5361
5362
5363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5364   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5365   float arg2 ;
5366
5367   arg1 = (Dali::Vector2 *)jarg1;
5368   arg2 = (float)jarg2;
5369   if (arg1) (arg1)->width = arg2;
5370 }
5371
5372
5373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5374   float jresult ;
5375   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5376   float result;
5377
5378   arg1 = (Dali::Vector2 *)jarg1;
5379   result = (float) ((arg1)->width);
5380   jresult = result;
5381   return jresult;
5382 }
5383
5384
5385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5386   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5387   float arg2 ;
5388
5389   arg1 = (Dali::Vector2 *)jarg1;
5390   arg2 = (float)jarg2;
5391   if (arg1) (arg1)->y = arg2;
5392 }
5393
5394
5395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5396   float jresult ;
5397   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5398   float result;
5399
5400   arg1 = (Dali::Vector2 *)jarg1;
5401   result = (float) ((arg1)->y);
5402   jresult = result;
5403   return jresult;
5404 }
5405
5406
5407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5408   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5409   float arg2 ;
5410
5411   arg1 = (Dali::Vector2 *)jarg1;
5412   arg2 = (float)jarg2;
5413   if (arg1) (arg1)->height = arg2;
5414 }
5415
5416
5417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5418   float jresult ;
5419   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5420   float result;
5421
5422   arg1 = (Dali::Vector2 *)jarg1;
5423   result = (float) ((arg1)->height);
5424   jresult = result;
5425   return jresult;
5426 }
5427
5428
5429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5430   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5431
5432   arg1 = (Dali::Vector2 *)jarg1;
5433   {
5434     try {
5435       delete arg1;
5436     } catch (std::out_of_range& e) {
5437       {
5438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5439       };
5440     } catch (std::exception& e) {
5441       {
5442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5443       };
5444     } catch (Dali::DaliException e) {
5445       {
5446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5447       };
5448     } catch (...) {
5449       {
5450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5451       };
5452     }
5453   }
5454
5455 }
5456
5457
5458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5459   void * jresult ;
5460   Dali::Vector2 *arg1 = 0 ;
5461   Dali::Vector2 *arg2 = 0 ;
5462   Dali::Vector2 result;
5463
5464   arg1 = (Dali::Vector2 *)jarg1;
5465   if (!arg1) {
5466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5467     return 0;
5468   }
5469   arg2 = (Dali::Vector2 *)jarg2;
5470   if (!arg2) {
5471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5472     return 0;
5473   }
5474   {
5475     try {
5476       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5477     } catch (std::out_of_range& e) {
5478       {
5479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5480       };
5481     } catch (std::exception& e) {
5482       {
5483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5484       };
5485     } catch (Dali::DaliException e) {
5486       {
5487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5488       };
5489     } catch (...) {
5490       {
5491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5492       };
5493     }
5494   }
5495
5496   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5497   return jresult;
5498 }
5499
5500
5501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5502   void * jresult ;
5503   Dali::Vector2 *arg1 = 0 ;
5504   Dali::Vector2 *arg2 = 0 ;
5505   Dali::Vector2 result;
5506
5507   arg1 = (Dali::Vector2 *)jarg1;
5508   if (!arg1) {
5509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5510     return 0;
5511   }
5512   arg2 = (Dali::Vector2 *)jarg2;
5513   if (!arg2) {
5514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5515     return 0;
5516   }
5517   {
5518     try {
5519       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5520     } catch (std::out_of_range& e) {
5521       {
5522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (std::exception& e) {
5525       {
5526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5527       };
5528     } catch (Dali::DaliException e) {
5529       {
5530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5531       };
5532     } catch (...) {
5533       {
5534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5535       };
5536     }
5537   }
5538
5539   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5540   return jresult;
5541 }
5542
5543
5544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5545   void * jresult ;
5546   Dali::Vector2 *arg1 = 0 ;
5547   float *arg2 = 0 ;
5548   float *arg3 = 0 ;
5549   float temp2 ;
5550   float temp3 ;
5551   Dali::Vector2 result;
5552
5553   arg1 = (Dali::Vector2 *)jarg1;
5554   if (!arg1) {
5555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5556     return 0;
5557   }
5558   temp2 = (float)jarg2;
5559   arg2 = &temp2;
5560   temp3 = (float)jarg3;
5561   arg3 = &temp3;
5562   {
5563     try {
5564       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5565     } catch (std::out_of_range& e) {
5566       {
5567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5568       };
5569     } catch (std::exception& e) {
5570       {
5571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5572       };
5573     } catch (Dali::DaliException e) {
5574       {
5575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5576       };
5577     } catch (...) {
5578       {
5579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5580       };
5581     }
5582   }
5583
5584   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5585   return jresult;
5586 }
5587
5588
5589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5590   void * jresult ;
5591   Dali::Vector3 *result = 0 ;
5592
5593   {
5594     try {
5595       result = (Dali::Vector3 *)new Dali::Vector3();
5596     } catch (std::out_of_range& e) {
5597       {
5598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5599       };
5600     } catch (std::exception& e) {
5601       {
5602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5603       };
5604     } catch (Dali::DaliException e) {
5605       {
5606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5607       };
5608     } catch (...) {
5609       {
5610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5611       };
5612     }
5613   }
5614
5615   jresult = (void *)result;
5616   return jresult;
5617 }
5618
5619
5620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5621   void * jresult ;
5622   float arg1 ;
5623   float arg2 ;
5624   float arg3 ;
5625   Dali::Vector3 *result = 0 ;
5626
5627   arg1 = (float)jarg1;
5628   arg2 = (float)jarg2;
5629   arg3 = (float)jarg3;
5630   {
5631     try {
5632       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5633     } catch (std::out_of_range& e) {
5634       {
5635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5636       };
5637     } catch (std::exception& e) {
5638       {
5639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5640       };
5641     } catch (Dali::DaliException e) {
5642       {
5643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5644       };
5645     } catch (...) {
5646       {
5647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5648       };
5649     }
5650   }
5651
5652   jresult = (void *)result;
5653   return jresult;
5654 }
5655
5656
5657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5658   void * jresult ;
5659   float *arg1 = (float *) 0 ;
5660   Dali::Vector3 *result = 0 ;
5661
5662   arg1 = jarg1;
5663   {
5664     try {
5665       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5666     } catch (std::out_of_range& e) {
5667       {
5668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5669       };
5670     } catch (std::exception& e) {
5671       {
5672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5673       };
5674     } catch (Dali::DaliException e) {
5675       {
5676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5677       };
5678     } catch (...) {
5679       {
5680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5681       };
5682     }
5683   }
5684
5685   jresult = (void *)result;
5686
5687
5688   return jresult;
5689 }
5690
5691
5692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5693   void * jresult ;
5694   Dali::Vector2 *arg1 = 0 ;
5695   Dali::Vector3 *result = 0 ;
5696
5697   arg1 = (Dali::Vector2 *)jarg1;
5698   if (!arg1) {
5699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5700     return 0;
5701   }
5702   {
5703     try {
5704       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5705     } catch (std::out_of_range& e) {
5706       {
5707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5708       };
5709     } catch (std::exception& e) {
5710       {
5711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5712       };
5713     } catch (Dali::DaliException e) {
5714       {
5715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5716       };
5717     } catch (...) {
5718       {
5719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5720       };
5721     }
5722   }
5723
5724   jresult = (void *)result;
5725   return jresult;
5726 }
5727
5728
5729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5730   void * jresult ;
5731   Dali::Vector4 *arg1 = 0 ;
5732   Dali::Vector3 *result = 0 ;
5733
5734   arg1 = (Dali::Vector4 *)jarg1;
5735   if (!arg1) {
5736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5737     return 0;
5738   }
5739   {
5740     try {
5741       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5742     } catch (std::out_of_range& e) {
5743       {
5744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5745       };
5746     } catch (std::exception& e) {
5747       {
5748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5749       };
5750     } catch (Dali::DaliException e) {
5751       {
5752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5753       };
5754     } catch (...) {
5755       {
5756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5757       };
5758     }
5759   }
5760
5761   jresult = (void *)result;
5762   return jresult;
5763 }
5764
5765
5766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5767   void * jresult ;
5768   Dali::Vector3 *result = 0 ;
5769
5770   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5771   jresult = (void *)result;
5772   return jresult;
5773 }
5774
5775
5776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5777   void * jresult ;
5778   Dali::Vector3 *result = 0 ;
5779
5780   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5781   jresult = (void *)result;
5782   return jresult;
5783 }
5784
5785
5786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5787   void * jresult ;
5788   Dali::Vector3 *result = 0 ;
5789
5790   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5791   jresult = (void *)result;
5792   return jresult;
5793 }
5794
5795
5796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5797   void * jresult ;
5798   Dali::Vector3 *result = 0 ;
5799
5800   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5801   jresult = (void *)result;
5802   return jresult;
5803 }
5804
5805
5806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5807   void * jresult ;
5808   Dali::Vector3 *result = 0 ;
5809
5810   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5811   jresult = (void *)result;
5812   return jresult;
5813 }
5814
5815
5816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5817   void * jresult ;
5818   Dali::Vector3 *result = 0 ;
5819
5820   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5821   jresult = (void *)result;
5822   return jresult;
5823 }
5824
5825
5826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5827   void * jresult ;
5828   Dali::Vector3 *result = 0 ;
5829
5830   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5831   jresult = (void *)result;
5832   return jresult;
5833 }
5834
5835
5836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5837   void * jresult ;
5838   Dali::Vector3 *result = 0 ;
5839
5840   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5841   jresult = (void *)result;
5842   return jresult;
5843 }
5844
5845
5846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5847   void * jresult ;
5848   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5849   float *arg2 = (float *) 0 ;
5850   Dali::Vector3 *result = 0 ;
5851
5852   arg1 = (Dali::Vector3 *)jarg1;
5853   arg2 = jarg2;
5854   {
5855     try {
5856       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5857     } catch (std::out_of_range& e) {
5858       {
5859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5860       };
5861     } catch (std::exception& e) {
5862       {
5863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5864       };
5865     } catch (Dali::DaliException e) {
5866       {
5867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5868       };
5869     } catch (...) {
5870       {
5871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5872       };
5873     }
5874   }
5875
5876   jresult = (void *)result;
5877
5878
5879   return jresult;
5880 }
5881
5882
5883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5884   void * jresult ;
5885   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5886   Dali::Vector2 *arg2 = 0 ;
5887   Dali::Vector3 *result = 0 ;
5888
5889   arg1 = (Dali::Vector3 *)jarg1;
5890   arg2 = (Dali::Vector2 *)jarg2;
5891   if (!arg2) {
5892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5893     return 0;
5894   }
5895   {
5896     try {
5897       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5898     } catch (std::out_of_range& e) {
5899       {
5900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5901       };
5902     } catch (std::exception& e) {
5903       {
5904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5905       };
5906     } catch (Dali::DaliException e) {
5907       {
5908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5909       };
5910     } catch (...) {
5911       {
5912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5913       };
5914     }
5915   }
5916
5917   jresult = (void *)result;
5918   return jresult;
5919 }
5920
5921
5922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5923   void * jresult ;
5924   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5925   Dali::Vector4 *arg2 = 0 ;
5926   Dali::Vector3 *result = 0 ;
5927
5928   arg1 = (Dali::Vector3 *)jarg1;
5929   arg2 = (Dali::Vector4 *)jarg2;
5930   if (!arg2) {
5931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5932     return 0;
5933   }
5934   {
5935     try {
5936       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5937     } catch (std::out_of_range& e) {
5938       {
5939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5940       };
5941     } catch (std::exception& e) {
5942       {
5943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5944       };
5945     } catch (Dali::DaliException e) {
5946       {
5947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5948       };
5949     } catch (...) {
5950       {
5951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5952       };
5953     }
5954   }
5955
5956   jresult = (void *)result;
5957   return jresult;
5958 }
5959
5960
5961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5962   void * jresult ;
5963   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5964   Dali::Vector3 *arg2 = 0 ;
5965   Dali::Vector3 result;
5966
5967   arg1 = (Dali::Vector3 *)jarg1;
5968   arg2 = (Dali::Vector3 *)jarg2;
5969   if (!arg2) {
5970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5971     return 0;
5972   }
5973   {
5974     try {
5975       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5976     } catch (std::out_of_range& e) {
5977       {
5978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5979       };
5980     } catch (std::exception& e) {
5981       {
5982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5983       };
5984     } catch (Dali::DaliException e) {
5985       {
5986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5987       };
5988     } catch (...) {
5989       {
5990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5991       };
5992     }
5993   }
5994
5995   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5996   return jresult;
5997 }
5998
5999
6000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
6001   void * jresult ;
6002   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6003   Dali::Vector3 *arg2 = 0 ;
6004   Dali::Vector3 *result = 0 ;
6005
6006   arg1 = (Dali::Vector3 *)jarg1;
6007   arg2 = (Dali::Vector3 *)jarg2;
6008   if (!arg2) {
6009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6010     return 0;
6011   }
6012   {
6013     try {
6014       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6015     } catch (std::out_of_range& e) {
6016       {
6017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6018       };
6019     } catch (std::exception& e) {
6020       {
6021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6022       };
6023     } catch (Dali::DaliException e) {
6024       {
6025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6026       };
6027     } catch (...) {
6028       {
6029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6030       };
6031     }
6032   }
6033
6034   jresult = (void *)result;
6035   return jresult;
6036 }
6037
6038
6039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6040   void * jresult ;
6041   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6042   Dali::Vector3 *arg2 = 0 ;
6043   Dali::Vector3 result;
6044
6045   arg1 = (Dali::Vector3 *)jarg1;
6046   arg2 = (Dali::Vector3 *)jarg2;
6047   if (!arg2) {
6048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6049     return 0;
6050   }
6051   {
6052     try {
6053       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6054     } catch (std::out_of_range& e) {
6055       {
6056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6057       };
6058     } catch (std::exception& e) {
6059       {
6060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6061       };
6062     } catch (Dali::DaliException e) {
6063       {
6064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6065       };
6066     } catch (...) {
6067       {
6068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6069       };
6070     }
6071   }
6072
6073   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6074   return jresult;
6075 }
6076
6077
6078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6079   void * jresult ;
6080   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6081   Dali::Vector3 *arg2 = 0 ;
6082   Dali::Vector3 *result = 0 ;
6083
6084   arg1 = (Dali::Vector3 *)jarg1;
6085   arg2 = (Dali::Vector3 *)jarg2;
6086   if (!arg2) {
6087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6088     return 0;
6089   }
6090   {
6091     try {
6092       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6093     } catch (std::out_of_range& e) {
6094       {
6095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6096       };
6097     } catch (std::exception& e) {
6098       {
6099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6100       };
6101     } catch (Dali::DaliException e) {
6102       {
6103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6104       };
6105     } catch (...) {
6106       {
6107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6108       };
6109     }
6110   }
6111
6112   jresult = (void *)result;
6113   return jresult;
6114 }
6115
6116
6117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6118   void * jresult ;
6119   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6120   Dali::Vector3 *arg2 = 0 ;
6121   Dali::Vector3 result;
6122
6123   arg1 = (Dali::Vector3 *)jarg1;
6124   arg2 = (Dali::Vector3 *)jarg2;
6125   if (!arg2) {
6126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6127     return 0;
6128   }
6129   {
6130     try {
6131       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6132     } catch (std::out_of_range& e) {
6133       {
6134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6135       };
6136     } catch (std::exception& e) {
6137       {
6138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6139       };
6140     } catch (Dali::DaliException e) {
6141       {
6142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6143       };
6144     } catch (...) {
6145       {
6146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6147       };
6148     }
6149   }
6150
6151   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6152   return jresult;
6153 }
6154
6155
6156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6157   void * jresult ;
6158   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6159   float arg2 ;
6160   Dali::Vector3 result;
6161
6162   arg1 = (Dali::Vector3 *)jarg1;
6163   arg2 = (float)jarg2;
6164   {
6165     try {
6166       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6167     } catch (std::out_of_range& e) {
6168       {
6169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6170       };
6171     } catch (std::exception& e) {
6172       {
6173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6174       };
6175     } catch (Dali::DaliException e) {
6176       {
6177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6178       };
6179     } catch (...) {
6180       {
6181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6182       };
6183     }
6184   }
6185
6186   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6187   return jresult;
6188 }
6189
6190
6191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6192   void * jresult ;
6193   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6194   Dali::Vector3 *arg2 = 0 ;
6195   Dali::Vector3 *result = 0 ;
6196
6197   arg1 = (Dali::Vector3 *)jarg1;
6198   arg2 = (Dali::Vector3 *)jarg2;
6199   if (!arg2) {
6200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6201     return 0;
6202   }
6203   {
6204     try {
6205       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6206     } catch (std::out_of_range& e) {
6207       {
6208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6209       };
6210     } catch (std::exception& e) {
6211       {
6212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6213       };
6214     } catch (Dali::DaliException e) {
6215       {
6216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6217       };
6218     } catch (...) {
6219       {
6220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6221       };
6222     }
6223   }
6224
6225   jresult = (void *)result;
6226   return jresult;
6227 }
6228
6229
6230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6231   void * jresult ;
6232   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6233   float arg2 ;
6234   Dali::Vector3 *result = 0 ;
6235
6236   arg1 = (Dali::Vector3 *)jarg1;
6237   arg2 = (float)jarg2;
6238   {
6239     try {
6240       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6241     } catch (std::out_of_range& e) {
6242       {
6243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6244       };
6245     } catch (std::exception& e) {
6246       {
6247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6248       };
6249     } catch (Dali::DaliException e) {
6250       {
6251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6252       };
6253     } catch (...) {
6254       {
6255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6256       };
6257     }
6258   }
6259
6260   jresult = (void *)result;
6261   return jresult;
6262 }
6263
6264
6265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6266   void * jresult ;
6267   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6268   Dali::Quaternion *arg2 = 0 ;
6269   Dali::Vector3 *result = 0 ;
6270
6271   arg1 = (Dali::Vector3 *)jarg1;
6272   arg2 = (Dali::Quaternion *)jarg2;
6273   if (!arg2) {
6274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6275     return 0;
6276   }
6277   {
6278     try {
6279       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6280     } catch (std::out_of_range& e) {
6281       {
6282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6283       };
6284     } catch (std::exception& e) {
6285       {
6286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6287       };
6288     } catch (Dali::DaliException e) {
6289       {
6290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6291       };
6292     } catch (...) {
6293       {
6294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6295       };
6296     }
6297   }
6298
6299   jresult = (void *)result;
6300   return jresult;
6301 }
6302
6303
6304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6305   void * jresult ;
6306   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6307   Dali::Vector3 *arg2 = 0 ;
6308   Dali::Vector3 result;
6309
6310   arg1 = (Dali::Vector3 *)jarg1;
6311   arg2 = (Dali::Vector3 *)jarg2;
6312   if (!arg2) {
6313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6314     return 0;
6315   }
6316   {
6317     try {
6318       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6319     } catch (std::out_of_range& e) {
6320       {
6321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6322       };
6323     } catch (std::exception& e) {
6324       {
6325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6326       };
6327     } catch (Dali::DaliException e) {
6328       {
6329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6330       };
6331     } catch (...) {
6332       {
6333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6334       };
6335     }
6336   }
6337
6338   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6339   return jresult;
6340 }
6341
6342
6343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6344   void * jresult ;
6345   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6346   float arg2 ;
6347   Dali::Vector3 result;
6348
6349   arg1 = (Dali::Vector3 *)jarg1;
6350   arg2 = (float)jarg2;
6351   {
6352     try {
6353       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6354     } catch (std::out_of_range& e) {
6355       {
6356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6357       };
6358     } catch (std::exception& e) {
6359       {
6360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6361       };
6362     } catch (Dali::DaliException e) {
6363       {
6364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6365       };
6366     } catch (...) {
6367       {
6368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6369       };
6370     }
6371   }
6372
6373   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6374   return jresult;
6375 }
6376
6377
6378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6379   void * jresult ;
6380   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6381   Dali::Vector3 *arg2 = 0 ;
6382   Dali::Vector3 *result = 0 ;
6383
6384   arg1 = (Dali::Vector3 *)jarg1;
6385   arg2 = (Dali::Vector3 *)jarg2;
6386   if (!arg2) {
6387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6388     return 0;
6389   }
6390   {
6391     try {
6392       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6393     } catch (std::out_of_range& e) {
6394       {
6395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6396       };
6397     } catch (std::exception& e) {
6398       {
6399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6400       };
6401     } catch (Dali::DaliException e) {
6402       {
6403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6404       };
6405     } catch (...) {
6406       {
6407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6408       };
6409     }
6410   }
6411
6412   jresult = (void *)result;
6413   return jresult;
6414 }
6415
6416
6417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6418   void * jresult ;
6419   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6420   float arg2 ;
6421   Dali::Vector3 *result = 0 ;
6422
6423   arg1 = (Dali::Vector3 *)jarg1;
6424   arg2 = (float)jarg2;
6425   {
6426     try {
6427       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6428     } catch (std::out_of_range& e) {
6429       {
6430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6431       };
6432     } catch (std::exception& e) {
6433       {
6434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6435       };
6436     } catch (Dali::DaliException e) {
6437       {
6438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6439       };
6440     } catch (...) {
6441       {
6442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6443       };
6444     }
6445   }
6446
6447   jresult = (void *)result;
6448   return jresult;
6449 }
6450
6451
6452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6453   void * jresult ;
6454   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6455   Dali::Vector3 result;
6456
6457   arg1 = (Dali::Vector3 *)jarg1;
6458   {
6459     try {
6460       result = ((Dali::Vector3 const *)arg1)->operator -();
6461     } catch (std::out_of_range& e) {
6462       {
6463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6464       };
6465     } catch (std::exception& e) {
6466       {
6467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6468       };
6469     } catch (Dali::DaliException e) {
6470       {
6471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6472       };
6473     } catch (...) {
6474       {
6475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6476       };
6477     }
6478   }
6479
6480   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6481   return jresult;
6482 }
6483
6484
6485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6486   unsigned int jresult ;
6487   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6488   Dali::Vector3 *arg2 = 0 ;
6489   bool result;
6490
6491   arg1 = (Dali::Vector3 *)jarg1;
6492   arg2 = (Dali::Vector3 *)jarg2;
6493   if (!arg2) {
6494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6495     return 0;
6496   }
6497   {
6498     try {
6499       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6500     } catch (std::out_of_range& e) {
6501       {
6502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6503       };
6504     } catch (std::exception& e) {
6505       {
6506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6507       };
6508     } catch (Dali::DaliException e) {
6509       {
6510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6511       };
6512     } catch (...) {
6513       {
6514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6515       };
6516     }
6517   }
6518
6519   jresult = result;
6520   return jresult;
6521 }
6522
6523
6524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6525   unsigned int jresult ;
6526   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6527   Dali::Vector3 *arg2 = 0 ;
6528   bool result;
6529
6530   arg1 = (Dali::Vector3 *)jarg1;
6531   arg2 = (Dali::Vector3 *)jarg2;
6532   if (!arg2) {
6533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6534     return 0;
6535   }
6536   {
6537     try {
6538       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6539     } catch (std::out_of_range& e) {
6540       {
6541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6542       };
6543     } catch (std::exception& e) {
6544       {
6545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6546       };
6547     } catch (Dali::DaliException e) {
6548       {
6549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6550       };
6551     } catch (...) {
6552       {
6553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6554       };
6555     }
6556   }
6557
6558   jresult = result;
6559   return jresult;
6560 }
6561
6562
6563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6564   float jresult ;
6565   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6566   unsigned int arg2 ;
6567   float *result = 0 ;
6568
6569   arg1 = (Dali::Vector3 *)jarg1;
6570   arg2 = (unsigned int)jarg2;
6571   {
6572     try {
6573       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6574     } catch (std::out_of_range& e) {
6575       {
6576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6577       };
6578     } catch (std::exception& e) {
6579       {
6580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6581       };
6582     } catch (Dali::DaliException e) {
6583       {
6584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6585       };
6586     } catch (...) {
6587       {
6588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6589       };
6590     }
6591   }
6592
6593   jresult = *result;
6594   return jresult;
6595 }
6596
6597
6598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6599   float jresult ;
6600   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6601   Dali::Vector3 *arg2 = 0 ;
6602   float result;
6603
6604   arg1 = (Dali::Vector3 *)jarg1;
6605   arg2 = (Dali::Vector3 *)jarg2;
6606   if (!arg2) {
6607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6608     return 0;
6609   }
6610   {
6611     try {
6612       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6613     } catch (std::out_of_range& e) {
6614       {
6615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6616       };
6617     } catch (std::exception& e) {
6618       {
6619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6620       };
6621     } catch (Dali::DaliException e) {
6622       {
6623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6624       };
6625     } catch (...) {
6626       {
6627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6628       };
6629     }
6630   }
6631
6632   jresult = result;
6633   return jresult;
6634 }
6635
6636
6637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6638   void * jresult ;
6639   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6640   Dali::Vector3 *arg2 = 0 ;
6641   Dali::Vector3 result;
6642
6643   arg1 = (Dali::Vector3 *)jarg1;
6644   arg2 = (Dali::Vector3 *)jarg2;
6645   if (!arg2) {
6646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6647     return 0;
6648   }
6649   {
6650     try {
6651       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6652     } catch (std::out_of_range& e) {
6653       {
6654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6655       };
6656     } catch (std::exception& e) {
6657       {
6658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6659       };
6660     } catch (Dali::DaliException e) {
6661       {
6662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6663       };
6664     } catch (...) {
6665       {
6666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6667       };
6668     }
6669   }
6670
6671   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6672   return jresult;
6673 }
6674
6675
6676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6677   float jresult ;
6678   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6679   float result;
6680
6681   arg1 = (Dali::Vector3 *)jarg1;
6682   {
6683     try {
6684       result = (float)((Dali::Vector3 const *)arg1)->Length();
6685     } catch (std::out_of_range& e) {
6686       {
6687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6688       };
6689     } catch (std::exception& e) {
6690       {
6691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6692       };
6693     } catch (Dali::DaliException e) {
6694       {
6695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6696       };
6697     } catch (...) {
6698       {
6699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6700       };
6701     }
6702   }
6703
6704   jresult = result;
6705   return jresult;
6706 }
6707
6708
6709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6710   float jresult ;
6711   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6712   float result;
6713
6714   arg1 = (Dali::Vector3 *)jarg1;
6715   {
6716     try {
6717       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6718     } catch (std::out_of_range& e) {
6719       {
6720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6721       };
6722     } catch (std::exception& e) {
6723       {
6724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6725       };
6726     } catch (Dali::DaliException e) {
6727       {
6728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6729       };
6730     } catch (...) {
6731       {
6732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6733       };
6734     }
6735   }
6736
6737   jresult = result;
6738   return jresult;
6739 }
6740
6741
6742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6743   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6744
6745   arg1 = (Dali::Vector3 *)jarg1;
6746   {
6747     try {
6748       (arg1)->Normalize();
6749     } catch (std::out_of_range& e) {
6750       {
6751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6752       };
6753     } catch (std::exception& e) {
6754       {
6755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6756       };
6757     } catch (Dali::DaliException e) {
6758       {
6759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6760       };
6761     } catch (...) {
6762       {
6763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6764       };
6765     }
6766   }
6767
6768 }
6769
6770
6771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6772   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6773   Dali::Vector3 *arg2 = 0 ;
6774   Dali::Vector3 *arg3 = 0 ;
6775
6776   arg1 = (Dali::Vector3 *)jarg1;
6777   arg2 = (Dali::Vector3 *)jarg2;
6778   if (!arg2) {
6779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6780     return ;
6781   }
6782   arg3 = (Dali::Vector3 *)jarg3;
6783   if (!arg3) {
6784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6785     return ;
6786   }
6787   {
6788     try {
6789       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6790     } catch (std::out_of_range& e) {
6791       {
6792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6793       };
6794     } catch (std::exception& e) {
6795       {
6796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6797       };
6798     } catch (Dali::DaliException e) {
6799       {
6800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6801       };
6802     } catch (...) {
6803       {
6804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6805       };
6806     }
6807   }
6808
6809 }
6810
6811
6812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6813   void * jresult ;
6814   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6815   float *result = 0 ;
6816
6817   arg1 = (Dali::Vector3 *)jarg1;
6818   {
6819     try {
6820       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6821     } catch (std::out_of_range& e) {
6822       {
6823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6824       };
6825     } catch (std::exception& e) {
6826       {
6827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6828       };
6829     } catch (Dali::DaliException e) {
6830       {
6831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6832       };
6833     } catch (...) {
6834       {
6835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6836       };
6837     }
6838   }
6839
6840   jresult = (void *)result;
6841   return jresult;
6842 }
6843
6844
6845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6846   void * jresult ;
6847   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6848   Dali::Vector2 *result = 0 ;
6849
6850   arg1 = (Dali::Vector3 *)jarg1;
6851   {
6852     try {
6853       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6854     } catch (std::out_of_range& e) {
6855       {
6856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6857       };
6858     } catch (std::exception& e) {
6859       {
6860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6861       };
6862     } catch (Dali::DaliException e) {
6863       {
6864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6865       };
6866     } catch (...) {
6867       {
6868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6869       };
6870     }
6871   }
6872
6873   jresult = (void *)result;
6874   return jresult;
6875 }
6876
6877
6878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6879   void * jresult ;
6880   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6881   Dali::Vector2 *result = 0 ;
6882
6883   arg1 = (Dali::Vector3 *)jarg1;
6884   {
6885     try {
6886       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6887     } catch (std::out_of_range& e) {
6888       {
6889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6890       };
6891     } catch (std::exception& e) {
6892       {
6893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6894       };
6895     } catch (Dali::DaliException e) {
6896       {
6897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6898       };
6899     } catch (...) {
6900       {
6901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6902       };
6903     }
6904   }
6905
6906   jresult = (void *)result;
6907   return jresult;
6908 }
6909
6910
6911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6912   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6913   float arg2 ;
6914
6915   arg1 = (Dali::Vector3 *)jarg1;
6916   arg2 = (float)jarg2;
6917   if (arg1) (arg1)->x = arg2;
6918 }
6919
6920
6921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6922   float jresult ;
6923   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6924   float result;
6925
6926   arg1 = (Dali::Vector3 *)jarg1;
6927   result = (float) ((arg1)->x);
6928   jresult = result;
6929   return jresult;
6930 }
6931
6932
6933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6934   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6935   float arg2 ;
6936
6937   arg1 = (Dali::Vector3 *)jarg1;
6938   arg2 = (float)jarg2;
6939   if (arg1) (arg1)->width = arg2;
6940 }
6941
6942
6943 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6944   float jresult ;
6945   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6946   float result;
6947
6948   arg1 = (Dali::Vector3 *)jarg1;
6949   result = (float) ((arg1)->width);
6950   jresult = result;
6951   return jresult;
6952 }
6953
6954
6955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6956   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6957   float arg2 ;
6958
6959   arg1 = (Dali::Vector3 *)jarg1;
6960   arg2 = (float)jarg2;
6961   if (arg1) (arg1)->r = arg2;
6962 }
6963
6964
6965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6966   float jresult ;
6967   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6968   float result;
6969
6970   arg1 = (Dali::Vector3 *)jarg1;
6971   result = (float) ((arg1)->r);
6972   jresult = result;
6973   return jresult;
6974 }
6975
6976
6977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6978   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6979   float arg2 ;
6980
6981   arg1 = (Dali::Vector3 *)jarg1;
6982   arg2 = (float)jarg2;
6983   if (arg1) (arg1)->y = arg2;
6984 }
6985
6986
6987 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6988   float jresult ;
6989   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6990   float result;
6991
6992   arg1 = (Dali::Vector3 *)jarg1;
6993   result = (float) ((arg1)->y);
6994   jresult = result;
6995   return jresult;
6996 }
6997
6998
6999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
7000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7001   float arg2 ;
7002
7003   arg1 = (Dali::Vector3 *)jarg1;
7004   arg2 = (float)jarg2;
7005   if (arg1) (arg1)->height = arg2;
7006 }
7007
7008
7009 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7010   float jresult ;
7011   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7012   float result;
7013
7014   arg1 = (Dali::Vector3 *)jarg1;
7015   result = (float) ((arg1)->height);
7016   jresult = result;
7017   return jresult;
7018 }
7019
7020
7021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7022   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7023   float arg2 ;
7024
7025   arg1 = (Dali::Vector3 *)jarg1;
7026   arg2 = (float)jarg2;
7027   if (arg1) (arg1)->g = arg2;
7028 }
7029
7030
7031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7032   float jresult ;
7033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7034   float result;
7035
7036   arg1 = (Dali::Vector3 *)jarg1;
7037   result = (float) ((arg1)->g);
7038   jresult = result;
7039   return jresult;
7040 }
7041
7042
7043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7044   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7045   float arg2 ;
7046
7047   arg1 = (Dali::Vector3 *)jarg1;
7048   arg2 = (float)jarg2;
7049   if (arg1) (arg1)->z = arg2;
7050 }
7051
7052
7053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7054   float jresult ;
7055   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7056   float result;
7057
7058   arg1 = (Dali::Vector3 *)jarg1;
7059   result = (float) ((arg1)->z);
7060   jresult = result;
7061   return jresult;
7062 }
7063
7064
7065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7066   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7067   float arg2 ;
7068
7069   arg1 = (Dali::Vector3 *)jarg1;
7070   arg2 = (float)jarg2;
7071   if (arg1) (arg1)->depth = arg2;
7072 }
7073
7074
7075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7076   float jresult ;
7077   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7078   float result;
7079
7080   arg1 = (Dali::Vector3 *)jarg1;
7081   result = (float) ((arg1)->depth);
7082   jresult = result;
7083   return jresult;
7084 }
7085
7086
7087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7088   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7089   float arg2 ;
7090
7091   arg1 = (Dali::Vector3 *)jarg1;
7092   arg2 = (float)jarg2;
7093   if (arg1) (arg1)->b = arg2;
7094 }
7095
7096
7097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7098   float jresult ;
7099   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7100   float result;
7101
7102   arg1 = (Dali::Vector3 *)jarg1;
7103   result = (float) ((arg1)->b);
7104   jresult = result;
7105   return jresult;
7106 }
7107
7108
7109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7110   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7111
7112   arg1 = (Dali::Vector3 *)jarg1;
7113   {
7114     try {
7115       delete arg1;
7116     } catch (std::out_of_range& e) {
7117       {
7118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7119       };
7120     } catch (std::exception& e) {
7121       {
7122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7123       };
7124     } catch (Dali::DaliException e) {
7125       {
7126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7127       };
7128     } catch (...) {
7129       {
7130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7131       };
7132     }
7133   }
7134
7135 }
7136
7137
7138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7139   void * jresult ;
7140   Dali::Vector3 *arg1 = 0 ;
7141   Dali::Vector3 *arg2 = 0 ;
7142   Dali::Vector3 result;
7143
7144   arg1 = (Dali::Vector3 *)jarg1;
7145   if (!arg1) {
7146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7147     return 0;
7148   }
7149   arg2 = (Dali::Vector3 *)jarg2;
7150   if (!arg2) {
7151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7152     return 0;
7153   }
7154   {
7155     try {
7156       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7157     } catch (std::out_of_range& e) {
7158       {
7159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (std::exception& e) {
7162       {
7163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7164       };
7165     } catch (Dali::DaliException e) {
7166       {
7167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7168       };
7169     } catch (...) {
7170       {
7171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7172       };
7173     }
7174   }
7175
7176   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7177   return jresult;
7178 }
7179
7180
7181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7182   void * jresult ;
7183   Dali::Vector3 *arg1 = 0 ;
7184   Dali::Vector3 *arg2 = 0 ;
7185   Dali::Vector3 result;
7186
7187   arg1 = (Dali::Vector3 *)jarg1;
7188   if (!arg1) {
7189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7190     return 0;
7191   }
7192   arg2 = (Dali::Vector3 *)jarg2;
7193   if (!arg2) {
7194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7195     return 0;
7196   }
7197   {
7198     try {
7199       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7200     } catch (std::out_of_range& e) {
7201       {
7202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7203       };
7204     } catch (std::exception& e) {
7205       {
7206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7207       };
7208     } catch (Dali::DaliException e) {
7209       {
7210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7211       };
7212     } catch (...) {
7213       {
7214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7215       };
7216     }
7217   }
7218
7219   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7220   return jresult;
7221 }
7222
7223
7224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7225   void * jresult ;
7226   Dali::Vector3 *arg1 = 0 ;
7227   float *arg2 = 0 ;
7228   float *arg3 = 0 ;
7229   float temp2 ;
7230   float temp3 ;
7231   Dali::Vector3 result;
7232
7233   arg1 = (Dali::Vector3 *)jarg1;
7234   if (!arg1) {
7235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7236     return 0;
7237   }
7238   temp2 = (float)jarg2;
7239   arg2 = &temp2;
7240   temp3 = (float)jarg3;
7241   arg3 = &temp3;
7242   {
7243     try {
7244       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7245     } catch (std::out_of_range& e) {
7246       {
7247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7248       };
7249     } catch (std::exception& e) {
7250       {
7251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7252       };
7253     } catch (Dali::DaliException e) {
7254       {
7255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7256       };
7257     } catch (...) {
7258       {
7259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7260       };
7261     }
7262   }
7263
7264   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7265   return jresult;
7266 }
7267
7268
7269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7270   void * jresult ;
7271   Dali::Vector4 *result = 0 ;
7272
7273   {
7274     try {
7275       result = (Dali::Vector4 *)new Dali::Vector4();
7276     } catch (std::out_of_range& e) {
7277       {
7278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7279       };
7280     } catch (std::exception& e) {
7281       {
7282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7283       };
7284     } catch (Dali::DaliException e) {
7285       {
7286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7287       };
7288     } catch (...) {
7289       {
7290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7291       };
7292     }
7293   }
7294
7295   jresult = (void *)result;
7296   return jresult;
7297 }
7298
7299
7300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7301   void * jresult ;
7302   float arg1 ;
7303   float arg2 ;
7304   float arg3 ;
7305   float arg4 ;
7306   Dali::Vector4 *result = 0 ;
7307
7308   arg1 = (float)jarg1;
7309   arg2 = (float)jarg2;
7310   arg3 = (float)jarg3;
7311   arg4 = (float)jarg4;
7312   {
7313     try {
7314       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7315     } catch (std::out_of_range& e) {
7316       {
7317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7318       };
7319     } catch (std::exception& e) {
7320       {
7321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7322       };
7323     } catch (Dali::DaliException e) {
7324       {
7325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7326       };
7327     } catch (...) {
7328       {
7329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7330       };
7331     }
7332   }
7333
7334   jresult = (void *)result;
7335   return jresult;
7336 }
7337
7338
7339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7340   void * jresult ;
7341   float *arg1 = (float *) 0 ;
7342   Dali::Vector4 *result = 0 ;
7343
7344   arg1 = jarg1;
7345   {
7346     try {
7347       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7348     } catch (std::out_of_range& e) {
7349       {
7350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7351       };
7352     } catch (std::exception& e) {
7353       {
7354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7355       };
7356     } catch (Dali::DaliException e) {
7357       {
7358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7359       };
7360     } catch (...) {
7361       {
7362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7363       };
7364     }
7365   }
7366
7367   jresult = (void *)result;
7368
7369
7370   return jresult;
7371 }
7372
7373
7374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7375   void * jresult ;
7376   Dali::Vector2 *arg1 = 0 ;
7377   Dali::Vector4 *result = 0 ;
7378
7379   arg1 = (Dali::Vector2 *)jarg1;
7380   if (!arg1) {
7381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7382     return 0;
7383   }
7384   {
7385     try {
7386       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7387     } catch (std::out_of_range& e) {
7388       {
7389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7390       };
7391     } catch (std::exception& e) {
7392       {
7393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7394       };
7395     } catch (Dali::DaliException e) {
7396       {
7397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7398       };
7399     } catch (...) {
7400       {
7401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7402       };
7403     }
7404   }
7405
7406   jresult = (void *)result;
7407   return jresult;
7408 }
7409
7410
7411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7412   void * jresult ;
7413   Dali::Vector3 *arg1 = 0 ;
7414   Dali::Vector4 *result = 0 ;
7415
7416   arg1 = (Dali::Vector3 *)jarg1;
7417   if (!arg1) {
7418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7419     return 0;
7420   }
7421   {
7422     try {
7423       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7424     } catch (std::out_of_range& e) {
7425       {
7426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7427       };
7428     } catch (std::exception& e) {
7429       {
7430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7431       };
7432     } catch (Dali::DaliException e) {
7433       {
7434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7435       };
7436     } catch (...) {
7437       {
7438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7439       };
7440     }
7441   }
7442
7443   jresult = (void *)result;
7444   return jresult;
7445 }
7446
7447
7448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7449   void * jresult ;
7450   Dali::Vector4 *result = 0 ;
7451
7452   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7453   jresult = (void *)result;
7454   return jresult;
7455 }
7456
7457
7458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7459   void * jresult ;
7460   Dali::Vector4 *result = 0 ;
7461
7462   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7463   jresult = (void *)result;
7464   return jresult;
7465 }
7466
7467
7468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7469   void * jresult ;
7470   Dali::Vector4 *result = 0 ;
7471
7472   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7473   jresult = (void *)result;
7474   return jresult;
7475 }
7476
7477
7478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7479   void * jresult ;
7480   Dali::Vector4 *result = 0 ;
7481
7482   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7483   jresult = (void *)result;
7484   return jresult;
7485 }
7486
7487
7488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7489   void * jresult ;
7490   Dali::Vector4 *result = 0 ;
7491
7492   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7493   jresult = (void *)result;
7494   return jresult;
7495 }
7496
7497
7498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7499   void * jresult ;
7500   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7501   float *arg2 = (float *) 0 ;
7502   Dali::Vector4 *result = 0 ;
7503
7504   arg1 = (Dali::Vector4 *)jarg1;
7505   arg2 = jarg2;
7506   {
7507     try {
7508       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7509     } catch (std::out_of_range& e) {
7510       {
7511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7512       };
7513     } catch (std::exception& e) {
7514       {
7515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7516       };
7517     } catch (Dali::DaliException e) {
7518       {
7519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7520       };
7521     } catch (...) {
7522       {
7523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7524       };
7525     }
7526   }
7527
7528   jresult = (void *)result;
7529
7530
7531   return jresult;
7532 }
7533
7534
7535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7536   void * jresult ;
7537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7538   Dali::Vector2 *arg2 = 0 ;
7539   Dali::Vector4 *result = 0 ;
7540
7541   arg1 = (Dali::Vector4 *)jarg1;
7542   arg2 = (Dali::Vector2 *)jarg2;
7543   if (!arg2) {
7544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7545     return 0;
7546   }
7547   {
7548     try {
7549       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7550     } catch (std::out_of_range& e) {
7551       {
7552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7553       };
7554     } catch (std::exception& e) {
7555       {
7556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7557       };
7558     } catch (Dali::DaliException e) {
7559       {
7560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7561       };
7562     } catch (...) {
7563       {
7564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7565       };
7566     }
7567   }
7568
7569   jresult = (void *)result;
7570   return jresult;
7571 }
7572
7573
7574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7575   void * jresult ;
7576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7577   Dali::Vector3 *arg2 = 0 ;
7578   Dali::Vector4 *result = 0 ;
7579
7580   arg1 = (Dali::Vector4 *)jarg1;
7581   arg2 = (Dali::Vector3 *)jarg2;
7582   if (!arg2) {
7583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7584     return 0;
7585   }
7586   {
7587     try {
7588       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7589     } catch (std::out_of_range& e) {
7590       {
7591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7592       };
7593     } catch (std::exception& e) {
7594       {
7595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7596       };
7597     } catch (Dali::DaliException e) {
7598       {
7599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7600       };
7601     } catch (...) {
7602       {
7603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7604       };
7605     }
7606   }
7607
7608   jresult = (void *)result;
7609   return jresult;
7610 }
7611
7612
7613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7614   void * jresult ;
7615   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7616   Dali::Vector4 *arg2 = 0 ;
7617   Dali::Vector4 result;
7618
7619   arg1 = (Dali::Vector4 *)jarg1;
7620   arg2 = (Dali::Vector4 *)jarg2;
7621   if (!arg2) {
7622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7623     return 0;
7624   }
7625   {
7626     try {
7627       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7628     } catch (std::out_of_range& e) {
7629       {
7630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7631       };
7632     } catch (std::exception& e) {
7633       {
7634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7635       };
7636     } catch (Dali::DaliException e) {
7637       {
7638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7639       };
7640     } catch (...) {
7641       {
7642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7643       };
7644     }
7645   }
7646
7647   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7648   return jresult;
7649 }
7650
7651
7652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7653   void * jresult ;
7654   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7655   Dali::Vector4 *arg2 = 0 ;
7656   Dali::Vector4 *result = 0 ;
7657
7658   arg1 = (Dali::Vector4 *)jarg1;
7659   arg2 = (Dali::Vector4 *)jarg2;
7660   if (!arg2) {
7661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7662     return 0;
7663   }
7664   {
7665     try {
7666       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7667     } catch (std::out_of_range& e) {
7668       {
7669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7670       };
7671     } catch (std::exception& e) {
7672       {
7673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7674       };
7675     } catch (Dali::DaliException e) {
7676       {
7677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7678       };
7679     } catch (...) {
7680       {
7681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7682       };
7683     }
7684   }
7685
7686   jresult = (void *)result;
7687   return jresult;
7688 }
7689
7690
7691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7692   void * jresult ;
7693   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7694   Dali::Vector4 *arg2 = 0 ;
7695   Dali::Vector4 result;
7696
7697   arg1 = (Dali::Vector4 *)jarg1;
7698   arg2 = (Dali::Vector4 *)jarg2;
7699   if (!arg2) {
7700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7701     return 0;
7702   }
7703   {
7704     try {
7705       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7706     } catch (std::out_of_range& e) {
7707       {
7708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7709       };
7710     } catch (std::exception& e) {
7711       {
7712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7713       };
7714     } catch (Dali::DaliException e) {
7715       {
7716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7717       };
7718     } catch (...) {
7719       {
7720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7721       };
7722     }
7723   }
7724
7725   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7726   return jresult;
7727 }
7728
7729
7730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7731   void * jresult ;
7732   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7733   Dali::Vector4 *arg2 = 0 ;
7734   Dali::Vector4 *result = 0 ;
7735
7736   arg1 = (Dali::Vector4 *)jarg1;
7737   arg2 = (Dali::Vector4 *)jarg2;
7738   if (!arg2) {
7739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7740     return 0;
7741   }
7742   {
7743     try {
7744       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7745     } catch (std::out_of_range& e) {
7746       {
7747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7748       };
7749     } catch (std::exception& e) {
7750       {
7751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7752       };
7753     } catch (Dali::DaliException e) {
7754       {
7755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7756       };
7757     } catch (...) {
7758       {
7759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7760       };
7761     }
7762   }
7763
7764   jresult = (void *)result;
7765   return jresult;
7766 }
7767
7768
7769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7770   void * jresult ;
7771   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7772   Dali::Vector4 *arg2 = 0 ;
7773   Dali::Vector4 result;
7774
7775   arg1 = (Dali::Vector4 *)jarg1;
7776   arg2 = (Dali::Vector4 *)jarg2;
7777   if (!arg2) {
7778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7779     return 0;
7780   }
7781   {
7782     try {
7783       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7784     } catch (std::out_of_range& e) {
7785       {
7786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7787       };
7788     } catch (std::exception& e) {
7789       {
7790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7791       };
7792     } catch (Dali::DaliException e) {
7793       {
7794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7795       };
7796     } catch (...) {
7797       {
7798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7799       };
7800     }
7801   }
7802
7803   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7804   return jresult;
7805 }
7806
7807
7808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7809   void * jresult ;
7810   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7811   float arg2 ;
7812   Dali::Vector4 result;
7813
7814   arg1 = (Dali::Vector4 *)jarg1;
7815   arg2 = (float)jarg2;
7816   {
7817     try {
7818       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7819     } catch (std::out_of_range& e) {
7820       {
7821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7822       };
7823     } catch (std::exception& e) {
7824       {
7825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7826       };
7827     } catch (Dali::DaliException e) {
7828       {
7829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7830       };
7831     } catch (...) {
7832       {
7833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7834       };
7835     }
7836   }
7837
7838   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7839   return jresult;
7840 }
7841
7842
7843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7844   void * jresult ;
7845   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7846   Dali::Vector4 *arg2 = 0 ;
7847   Dali::Vector4 *result = 0 ;
7848
7849   arg1 = (Dali::Vector4 *)jarg1;
7850   arg2 = (Dali::Vector4 *)jarg2;
7851   if (!arg2) {
7852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7853     return 0;
7854   }
7855   {
7856     try {
7857       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7858     } catch (std::out_of_range& e) {
7859       {
7860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7861       };
7862     } catch (std::exception& e) {
7863       {
7864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7865       };
7866     } catch (Dali::DaliException e) {
7867       {
7868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7869       };
7870     } catch (...) {
7871       {
7872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7873       };
7874     }
7875   }
7876
7877   jresult = (void *)result;
7878   return jresult;
7879 }
7880
7881
7882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7883   void * jresult ;
7884   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7885   float arg2 ;
7886   Dali::Vector4 *result = 0 ;
7887
7888   arg1 = (Dali::Vector4 *)jarg1;
7889   arg2 = (float)jarg2;
7890   {
7891     try {
7892       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7893     } catch (std::out_of_range& e) {
7894       {
7895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7896       };
7897     } catch (std::exception& e) {
7898       {
7899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7900       };
7901     } catch (Dali::DaliException e) {
7902       {
7903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7904       };
7905     } catch (...) {
7906       {
7907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7908       };
7909     }
7910   }
7911
7912   jresult = (void *)result;
7913   return jresult;
7914 }
7915
7916
7917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7918   void * jresult ;
7919   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7920   Dali::Vector4 *arg2 = 0 ;
7921   Dali::Vector4 result;
7922
7923   arg1 = (Dali::Vector4 *)jarg1;
7924   arg2 = (Dali::Vector4 *)jarg2;
7925   if (!arg2) {
7926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7927     return 0;
7928   }
7929   {
7930     try {
7931       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7932     } catch (std::out_of_range& e) {
7933       {
7934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7935       };
7936     } catch (std::exception& e) {
7937       {
7938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7939       };
7940     } catch (Dali::DaliException e) {
7941       {
7942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7943       };
7944     } catch (...) {
7945       {
7946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7947       };
7948     }
7949   }
7950
7951   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7952   return jresult;
7953 }
7954
7955
7956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7957   void * jresult ;
7958   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7959   float arg2 ;
7960   Dali::Vector4 result;
7961
7962   arg1 = (Dali::Vector4 *)jarg1;
7963   arg2 = (float)jarg2;
7964   {
7965     try {
7966       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7967     } catch (std::out_of_range& e) {
7968       {
7969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7970       };
7971     } catch (std::exception& e) {
7972       {
7973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7974       };
7975     } catch (Dali::DaliException e) {
7976       {
7977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7978       };
7979     } catch (...) {
7980       {
7981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7982       };
7983     }
7984   }
7985
7986   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7987   return jresult;
7988 }
7989
7990
7991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7992   void * jresult ;
7993   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7994   Dali::Vector4 *arg2 = 0 ;
7995   Dali::Vector4 *result = 0 ;
7996
7997   arg1 = (Dali::Vector4 *)jarg1;
7998   arg2 = (Dali::Vector4 *)jarg2;
7999   if (!arg2) {
8000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8001     return 0;
8002   }
8003   {
8004     try {
8005       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8006     } catch (std::out_of_range& e) {
8007       {
8008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8009       };
8010     } catch (std::exception& e) {
8011       {
8012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8013       };
8014     } catch (Dali::DaliException e) {
8015       {
8016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8017       };
8018     } catch (...) {
8019       {
8020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8021       };
8022     }
8023   }
8024
8025   jresult = (void *)result;
8026   return jresult;
8027 }
8028
8029
8030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8031   void * jresult ;
8032   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8033   float arg2 ;
8034   Dali::Vector4 *result = 0 ;
8035
8036   arg1 = (Dali::Vector4 *)jarg1;
8037   arg2 = (float)jarg2;
8038   {
8039     try {
8040       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8041     } catch (std::out_of_range& e) {
8042       {
8043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (std::exception& e) {
8046       {
8047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8048       };
8049     } catch (Dali::DaliException e) {
8050       {
8051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8052       };
8053     } catch (...) {
8054       {
8055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8056       };
8057     }
8058   }
8059
8060   jresult = (void *)result;
8061   return jresult;
8062 }
8063
8064
8065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8066   void * jresult ;
8067   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8068   Dali::Vector4 result;
8069
8070   arg1 = (Dali::Vector4 *)jarg1;
8071   {
8072     try {
8073       result = ((Dali::Vector4 const *)arg1)->operator -();
8074     } catch (std::out_of_range& e) {
8075       {
8076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8077       };
8078     } catch (std::exception& e) {
8079       {
8080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8081       };
8082     } catch (Dali::DaliException e) {
8083       {
8084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8085       };
8086     } catch (...) {
8087       {
8088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8089       };
8090     }
8091   }
8092
8093   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8094   return jresult;
8095 }
8096
8097
8098 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8099   unsigned int jresult ;
8100   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8101   Dali::Vector4 *arg2 = 0 ;
8102   bool result;
8103
8104   arg1 = (Dali::Vector4 *)jarg1;
8105   arg2 = (Dali::Vector4 *)jarg2;
8106   if (!arg2) {
8107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8108     return 0;
8109   }
8110   {
8111     try {
8112       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8113     } catch (std::out_of_range& e) {
8114       {
8115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8116       };
8117     } catch (std::exception& e) {
8118       {
8119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8120       };
8121     } catch (Dali::DaliException e) {
8122       {
8123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8124       };
8125     } catch (...) {
8126       {
8127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8128       };
8129     }
8130   }
8131
8132   jresult = result;
8133   return jresult;
8134 }
8135
8136
8137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8138   unsigned int jresult ;
8139   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8140   Dali::Vector4 *arg2 = 0 ;
8141   bool result;
8142
8143   arg1 = (Dali::Vector4 *)jarg1;
8144   arg2 = (Dali::Vector4 *)jarg2;
8145   if (!arg2) {
8146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8147     return 0;
8148   }
8149   {
8150     try {
8151       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8152     } catch (std::out_of_range& e) {
8153       {
8154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8155       };
8156     } catch (std::exception& e) {
8157       {
8158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8159       };
8160     } catch (Dali::DaliException e) {
8161       {
8162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8163       };
8164     } catch (...) {
8165       {
8166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8167       };
8168     }
8169   }
8170
8171   jresult = result;
8172   return jresult;
8173 }
8174
8175
8176 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8177   float jresult ;
8178   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8179   unsigned int arg2 ;
8180   float *result = 0 ;
8181
8182   arg1 = (Dali::Vector4 *)jarg1;
8183   arg2 = (unsigned int)jarg2;
8184   {
8185     try {
8186       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8187     } catch (std::out_of_range& e) {
8188       {
8189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8190       };
8191     } catch (std::exception& e) {
8192       {
8193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8194       };
8195     } catch (Dali::DaliException e) {
8196       {
8197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8198       };
8199     } catch (...) {
8200       {
8201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8202       };
8203     }
8204   }
8205
8206   jresult = *result;
8207   return jresult;
8208 }
8209
8210
8211 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8212   float jresult ;
8213   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8214   Dali::Vector3 *arg2 = 0 ;
8215   float result;
8216
8217   arg1 = (Dali::Vector4 *)jarg1;
8218   arg2 = (Dali::Vector3 *)jarg2;
8219   if (!arg2) {
8220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8221     return 0;
8222   }
8223   {
8224     try {
8225       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8226     } catch (std::out_of_range& e) {
8227       {
8228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8229       };
8230     } catch (std::exception& e) {
8231       {
8232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8233       };
8234     } catch (Dali::DaliException e) {
8235       {
8236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8237       };
8238     } catch (...) {
8239       {
8240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8241       };
8242     }
8243   }
8244
8245   jresult = result;
8246   return jresult;
8247 }
8248
8249
8250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8251   float jresult ;
8252   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8253   Dali::Vector4 *arg2 = 0 ;
8254   float result;
8255
8256   arg1 = (Dali::Vector4 *)jarg1;
8257   arg2 = (Dali::Vector4 *)jarg2;
8258   if (!arg2) {
8259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8260     return 0;
8261   }
8262   {
8263     try {
8264       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8265     } catch (std::out_of_range& e) {
8266       {
8267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8268       };
8269     } catch (std::exception& e) {
8270       {
8271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8272       };
8273     } catch (Dali::DaliException e) {
8274       {
8275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8276       };
8277     } catch (...) {
8278       {
8279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8280       };
8281     }
8282   }
8283
8284   jresult = result;
8285   return jresult;
8286 }
8287
8288
8289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8290   float jresult ;
8291   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8292   Dali::Vector4 *arg2 = 0 ;
8293   float result;
8294
8295   arg1 = (Dali::Vector4 *)jarg1;
8296   arg2 = (Dali::Vector4 *)jarg2;
8297   if (!arg2) {
8298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8299     return 0;
8300   }
8301   {
8302     try {
8303       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8304     } catch (std::out_of_range& e) {
8305       {
8306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8307       };
8308     } catch (std::exception& e) {
8309       {
8310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8311       };
8312     } catch (Dali::DaliException e) {
8313       {
8314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8315       };
8316     } catch (...) {
8317       {
8318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8319       };
8320     }
8321   }
8322
8323   jresult = result;
8324   return jresult;
8325 }
8326
8327
8328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8329   void * jresult ;
8330   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8331   Dali::Vector4 *arg2 = 0 ;
8332   Dali::Vector4 result;
8333
8334   arg1 = (Dali::Vector4 *)jarg1;
8335   arg2 = (Dali::Vector4 *)jarg2;
8336   if (!arg2) {
8337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8338     return 0;
8339   }
8340   {
8341     try {
8342       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8343     } catch (std::out_of_range& e) {
8344       {
8345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8346       };
8347     } catch (std::exception& e) {
8348       {
8349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8350       };
8351     } catch (Dali::DaliException e) {
8352       {
8353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8354       };
8355     } catch (...) {
8356       {
8357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8358       };
8359     }
8360   }
8361
8362   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8363   return jresult;
8364 }
8365
8366
8367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8368   float jresult ;
8369   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8370   float result;
8371
8372   arg1 = (Dali::Vector4 *)jarg1;
8373   {
8374     try {
8375       result = (float)((Dali::Vector4 const *)arg1)->Length();
8376     } catch (std::out_of_range& e) {
8377       {
8378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8379       };
8380     } catch (std::exception& e) {
8381       {
8382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8383       };
8384     } catch (Dali::DaliException e) {
8385       {
8386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8387       };
8388     } catch (...) {
8389       {
8390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8391       };
8392     }
8393   }
8394
8395   jresult = result;
8396   return jresult;
8397 }
8398
8399
8400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8401   float jresult ;
8402   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8403   float result;
8404
8405   arg1 = (Dali::Vector4 *)jarg1;
8406   {
8407     try {
8408       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8409     } catch (std::out_of_range& e) {
8410       {
8411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8412       };
8413     } catch (std::exception& e) {
8414       {
8415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8416       };
8417     } catch (Dali::DaliException e) {
8418       {
8419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8420       };
8421     } catch (...) {
8422       {
8423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8424       };
8425     }
8426   }
8427
8428   jresult = result;
8429   return jresult;
8430 }
8431
8432
8433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8434   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8435
8436   arg1 = (Dali::Vector4 *)jarg1;
8437   {
8438     try {
8439       (arg1)->Normalize();
8440     } catch (std::out_of_range& e) {
8441       {
8442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8443       };
8444     } catch (std::exception& e) {
8445       {
8446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8447       };
8448     } catch (Dali::DaliException e) {
8449       {
8450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8451       };
8452     } catch (...) {
8453       {
8454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8455       };
8456     }
8457   }
8458
8459 }
8460
8461
8462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8463   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8464   Dali::Vector4 *arg2 = 0 ;
8465   Dali::Vector4 *arg3 = 0 ;
8466
8467   arg1 = (Dali::Vector4 *)jarg1;
8468   arg2 = (Dali::Vector4 *)jarg2;
8469   if (!arg2) {
8470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8471     return ;
8472   }
8473   arg3 = (Dali::Vector4 *)jarg3;
8474   if (!arg3) {
8475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8476     return ;
8477   }
8478   {
8479     try {
8480       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8481     } catch (std::out_of_range& e) {
8482       {
8483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8484       };
8485     } catch (std::exception& e) {
8486       {
8487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8488       };
8489     } catch (Dali::DaliException e) {
8490       {
8491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8492       };
8493     } catch (...) {
8494       {
8495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8496       };
8497     }
8498   }
8499
8500 }
8501
8502
8503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8504   void * jresult ;
8505   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8506   float *result = 0 ;
8507
8508   arg1 = (Dali::Vector4 *)jarg1;
8509   {
8510     try {
8511       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8512     } catch (std::out_of_range& e) {
8513       {
8514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8515       };
8516     } catch (std::exception& e) {
8517       {
8518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8519       };
8520     } catch (Dali::DaliException e) {
8521       {
8522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8523       };
8524     } catch (...) {
8525       {
8526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8527       };
8528     }
8529   }
8530
8531   jresult = (void *)result;
8532   return jresult;
8533 }
8534
8535
8536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8537   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8538   float arg2 ;
8539
8540   arg1 = (Dali::Vector4 *)jarg1;
8541   arg2 = (float)jarg2;
8542   if (arg1) (arg1)->x = arg2;
8543 }
8544
8545
8546 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8547   float jresult ;
8548   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8549   float result;
8550
8551   arg1 = (Dali::Vector4 *)jarg1;
8552   result = (float) ((arg1)->x);
8553   jresult = result;
8554   return jresult;
8555 }
8556
8557
8558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8559   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8560   float arg2 ;
8561
8562   arg1 = (Dali::Vector4 *)jarg1;
8563   arg2 = (float)jarg2;
8564   if (arg1) (arg1)->r = arg2;
8565 }
8566
8567
8568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8569   float jresult ;
8570   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8571   float result;
8572
8573   arg1 = (Dali::Vector4 *)jarg1;
8574   result = (float) ((arg1)->r);
8575   jresult = result;
8576   return jresult;
8577 }
8578
8579
8580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8581   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8582   float arg2 ;
8583
8584   arg1 = (Dali::Vector4 *)jarg1;
8585   arg2 = (float)jarg2;
8586   if (arg1) (arg1)->s = arg2;
8587 }
8588
8589
8590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8591   float jresult ;
8592   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8593   float result;
8594
8595   arg1 = (Dali::Vector4 *)jarg1;
8596   result = (float) ((arg1)->s);
8597   jresult = result;
8598   return jresult;
8599 }
8600
8601
8602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8603   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8604   float arg2 ;
8605
8606   arg1 = (Dali::Vector4 *)jarg1;
8607   arg2 = (float)jarg2;
8608   if (arg1) (arg1)->y = arg2;
8609 }
8610
8611
8612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8613   float jresult ;
8614   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8615   float result;
8616
8617   arg1 = (Dali::Vector4 *)jarg1;
8618   result = (float) ((arg1)->y);
8619   jresult = result;
8620   return jresult;
8621 }
8622
8623
8624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8625   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8626   float arg2 ;
8627
8628   arg1 = (Dali::Vector4 *)jarg1;
8629   arg2 = (float)jarg2;
8630   if (arg1) (arg1)->g = arg2;
8631 }
8632
8633
8634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8635   float jresult ;
8636   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8637   float result;
8638
8639   arg1 = (Dali::Vector4 *)jarg1;
8640   result = (float) ((arg1)->g);
8641   jresult = result;
8642   return jresult;
8643 }
8644
8645
8646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8647   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8648   float arg2 ;
8649
8650   arg1 = (Dali::Vector4 *)jarg1;
8651   arg2 = (float)jarg2;
8652   if (arg1) (arg1)->t = arg2;
8653 }
8654
8655
8656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8657   float jresult ;
8658   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8659   float result;
8660
8661   arg1 = (Dali::Vector4 *)jarg1;
8662   result = (float) ((arg1)->t);
8663   jresult = result;
8664   return jresult;
8665 }
8666
8667
8668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8669   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8670   float arg2 ;
8671
8672   arg1 = (Dali::Vector4 *)jarg1;
8673   arg2 = (float)jarg2;
8674   if (arg1) (arg1)->z = arg2;
8675 }
8676
8677
8678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8679   float jresult ;
8680   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8681   float result;
8682
8683   arg1 = (Dali::Vector4 *)jarg1;
8684   result = (float) ((arg1)->z);
8685   jresult = result;
8686   return jresult;
8687 }
8688
8689
8690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8692   float arg2 ;
8693
8694   arg1 = (Dali::Vector4 *)jarg1;
8695   arg2 = (float)jarg2;
8696   if (arg1) (arg1)->b = arg2;
8697 }
8698
8699
8700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8701   float jresult ;
8702   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8703   float result;
8704
8705   arg1 = (Dali::Vector4 *)jarg1;
8706   result = (float) ((arg1)->b);
8707   jresult = result;
8708   return jresult;
8709 }
8710
8711
8712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8713   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8714   float arg2 ;
8715
8716   arg1 = (Dali::Vector4 *)jarg1;
8717   arg2 = (float)jarg2;
8718   if (arg1) (arg1)->p = arg2;
8719 }
8720
8721
8722 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8723   float jresult ;
8724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8725   float result;
8726
8727   arg1 = (Dali::Vector4 *)jarg1;
8728   result = (float) ((arg1)->p);
8729   jresult = result;
8730   return jresult;
8731 }
8732
8733
8734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8736   float arg2 ;
8737
8738   arg1 = (Dali::Vector4 *)jarg1;
8739   arg2 = (float)jarg2;
8740   if (arg1) (arg1)->w = arg2;
8741 }
8742
8743
8744 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8745   float jresult ;
8746   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8747   float result;
8748
8749   arg1 = (Dali::Vector4 *)jarg1;
8750   result = (float) ((arg1)->w);
8751   jresult = result;
8752   return jresult;
8753 }
8754
8755
8756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8757   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8758   float arg2 ;
8759
8760   arg1 = (Dali::Vector4 *)jarg1;
8761   arg2 = (float)jarg2;
8762   if (arg1) (arg1)->a = arg2;
8763 }
8764
8765
8766 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8767   float jresult ;
8768   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8769   float result;
8770
8771   arg1 = (Dali::Vector4 *)jarg1;
8772   result = (float) ((arg1)->a);
8773   jresult = result;
8774   return jresult;
8775 }
8776
8777
8778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8779   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8780   float arg2 ;
8781
8782   arg1 = (Dali::Vector4 *)jarg1;
8783   arg2 = (float)jarg2;
8784   if (arg1) (arg1)->q = arg2;
8785 }
8786
8787
8788 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8789   float jresult ;
8790   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8791   float result;
8792
8793   arg1 = (Dali::Vector4 *)jarg1;
8794   result = (float) ((arg1)->q);
8795   jresult = result;
8796   return jresult;
8797 }
8798
8799
8800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8801   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8802
8803   arg1 = (Dali::Vector4 *)jarg1;
8804   {
8805     try {
8806       delete arg1;
8807     } catch (std::out_of_range& e) {
8808       {
8809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8810       };
8811     } catch (std::exception& e) {
8812       {
8813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8814       };
8815     } catch (Dali::DaliException e) {
8816       {
8817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8818       };
8819     } catch (...) {
8820       {
8821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8822       };
8823     }
8824   }
8825
8826 }
8827
8828
8829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8830   void * jresult ;
8831   Dali::Vector4 *arg1 = 0 ;
8832   Dali::Vector4 *arg2 = 0 ;
8833   Dali::Vector4 result;
8834
8835   arg1 = (Dali::Vector4 *)jarg1;
8836   if (!arg1) {
8837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8838     return 0;
8839   }
8840   arg2 = (Dali::Vector4 *)jarg2;
8841   if (!arg2) {
8842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8843     return 0;
8844   }
8845   {
8846     try {
8847       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8848     } catch (std::out_of_range& e) {
8849       {
8850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8851       };
8852     } catch (std::exception& e) {
8853       {
8854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8855       };
8856     } catch (Dali::DaliException e) {
8857       {
8858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8859       };
8860     } catch (...) {
8861       {
8862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8863       };
8864     }
8865   }
8866
8867   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8868   return jresult;
8869 }
8870
8871
8872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8873   void * jresult ;
8874   Dali::Vector4 *arg1 = 0 ;
8875   Dali::Vector4 *arg2 = 0 ;
8876   Dali::Vector4 result;
8877
8878   arg1 = (Dali::Vector4 *)jarg1;
8879   if (!arg1) {
8880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8881     return 0;
8882   }
8883   arg2 = (Dali::Vector4 *)jarg2;
8884   if (!arg2) {
8885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8886     return 0;
8887   }
8888   {
8889     try {
8890       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8891     } catch (std::out_of_range& e) {
8892       {
8893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8894       };
8895     } catch (std::exception& e) {
8896       {
8897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8898       };
8899     } catch (Dali::DaliException e) {
8900       {
8901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8902       };
8903     } catch (...) {
8904       {
8905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8906       };
8907     }
8908   }
8909
8910   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8911   return jresult;
8912 }
8913
8914
8915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8916   void * jresult ;
8917   Dali::Vector4 *arg1 = 0 ;
8918   float *arg2 = 0 ;
8919   float *arg3 = 0 ;
8920   float temp2 ;
8921   float temp3 ;
8922   Dali::Vector4 result;
8923
8924   arg1 = (Dali::Vector4 *)jarg1;
8925   if (!arg1) {
8926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8927     return 0;
8928   }
8929   temp2 = (float)jarg2;
8930   arg2 = &temp2;
8931   temp3 = (float)jarg3;
8932   arg3 = &temp3;
8933   {
8934     try {
8935       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8936     } catch (std::out_of_range& e) {
8937       {
8938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8939       };
8940     } catch (std::exception& e) {
8941       {
8942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8943       };
8944     } catch (Dali::DaliException e) {
8945       {
8946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8947       };
8948     } catch (...) {
8949       {
8950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8951       };
8952     }
8953   }
8954
8955   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8956   return jresult;
8957 }
8958
8959
8960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8961   void * jresult ;
8962   Dali::Uint16Pair *result = 0 ;
8963
8964   {
8965     try {
8966       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8967     } catch (std::out_of_range& e) {
8968       {
8969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8970       };
8971     } catch (std::exception& e) {
8972       {
8973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8974       };
8975     } catch (Dali::DaliException e) {
8976       {
8977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8978       };
8979     } catch (...) {
8980       {
8981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8982       };
8983     }
8984   }
8985
8986   jresult = (void *)result;
8987   return jresult;
8988 }
8989
8990
8991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8992   void * jresult ;
8993   uint32_t arg1 ;
8994   uint32_t arg2 ;
8995   Dali::Uint16Pair *result = 0 ;
8996
8997   arg1 = (uint32_t)jarg1;
8998   arg2 = (uint32_t)jarg2;
8999   {
9000     try {
9001       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9002     } catch (std::out_of_range& e) {
9003       {
9004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9005       };
9006     } catch (std::exception& e) {
9007       {
9008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9009       };
9010     } catch (Dali::DaliException e) {
9011       {
9012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9013       };
9014     } catch (...) {
9015       {
9016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9017       };
9018     }
9019   }
9020
9021   jresult = (void *)result;
9022   return jresult;
9023 }
9024
9025
9026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9027   void * jresult ;
9028   Dali::Uint16Pair *arg1 = 0 ;
9029   Dali::Uint16Pair *result = 0 ;
9030
9031   arg1 = (Dali::Uint16Pair *)jarg1;
9032   if (!arg1) {
9033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9034     return 0;
9035   }
9036   {
9037     try {
9038       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9039     } catch (std::out_of_range& e) {
9040       {
9041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9042       };
9043     } catch (std::exception& e) {
9044       {
9045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9046       };
9047     } catch (Dali::DaliException e) {
9048       {
9049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9050       };
9051     } catch (...) {
9052       {
9053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9054       };
9055     }
9056   }
9057
9058   jresult = (void *)result;
9059   return jresult;
9060 }
9061
9062
9063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9064   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9065   uint16_t arg2 ;
9066
9067   arg1 = (Dali::Uint16Pair *)jarg1;
9068   arg2 = (uint16_t)jarg2;
9069   {
9070     try {
9071       (arg1)->SetWidth(arg2);
9072     } catch (std::out_of_range& e) {
9073       {
9074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9075       };
9076     } catch (std::exception& e) {
9077       {
9078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9079       };
9080     } catch (Dali::DaliException e) {
9081       {
9082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9083       };
9084     } catch (...) {
9085       {
9086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9087       };
9088     }
9089   }
9090
9091 }
9092
9093
9094 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9095   unsigned short jresult ;
9096   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9097   uint16_t result;
9098
9099   arg1 = (Dali::Uint16Pair *)jarg1;
9100   {
9101     try {
9102       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9103     } catch (std::out_of_range& e) {
9104       {
9105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9106       };
9107     } catch (std::exception& e) {
9108       {
9109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9110       };
9111     } catch (Dali::DaliException e) {
9112       {
9113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9114       };
9115     } catch (...) {
9116       {
9117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9118       };
9119     }
9120   }
9121
9122   jresult = result;
9123   return jresult;
9124 }
9125
9126
9127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9128   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9129   uint16_t arg2 ;
9130
9131   arg1 = (Dali::Uint16Pair *)jarg1;
9132   arg2 = (uint16_t)jarg2;
9133   {
9134     try {
9135       (arg1)->SetHeight(arg2);
9136     } catch (std::out_of_range& e) {
9137       {
9138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9139       };
9140     } catch (std::exception& e) {
9141       {
9142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9143       };
9144     } catch (Dali::DaliException e) {
9145       {
9146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9147       };
9148     } catch (...) {
9149       {
9150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9151       };
9152     }
9153   }
9154
9155 }
9156
9157
9158 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9159   unsigned short jresult ;
9160   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9161   uint16_t result;
9162
9163   arg1 = (Dali::Uint16Pair *)jarg1;
9164   {
9165     try {
9166       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9167     } catch (std::out_of_range& e) {
9168       {
9169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9170       };
9171     } catch (std::exception& e) {
9172       {
9173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9174       };
9175     } catch (Dali::DaliException e) {
9176       {
9177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9178       };
9179     } catch (...) {
9180       {
9181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9182       };
9183     }
9184   }
9185
9186   jresult = result;
9187   return jresult;
9188 }
9189
9190
9191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9192   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9193   uint16_t arg2 ;
9194
9195   arg1 = (Dali::Uint16Pair *)jarg1;
9196   arg2 = (uint16_t)jarg2;
9197   {
9198     try {
9199       (arg1)->SetX(arg2);
9200     } catch (std::out_of_range& e) {
9201       {
9202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9203       };
9204     } catch (std::exception& e) {
9205       {
9206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9207       };
9208     } catch (Dali::DaliException e) {
9209       {
9210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9211       };
9212     } catch (...) {
9213       {
9214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9215       };
9216     }
9217   }
9218
9219 }
9220
9221
9222 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9223   unsigned short jresult ;
9224   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9225   uint16_t result;
9226
9227   arg1 = (Dali::Uint16Pair *)jarg1;
9228   {
9229     try {
9230       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9231     } catch (std::out_of_range& e) {
9232       {
9233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9234       };
9235     } catch (std::exception& e) {
9236       {
9237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9238       };
9239     } catch (Dali::DaliException e) {
9240       {
9241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9242       };
9243     } catch (...) {
9244       {
9245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9246       };
9247     }
9248   }
9249
9250   jresult = result;
9251   return jresult;
9252 }
9253
9254
9255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9256   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9257   uint16_t arg2 ;
9258
9259   arg1 = (Dali::Uint16Pair *)jarg1;
9260   arg2 = (uint16_t)jarg2;
9261   {
9262     try {
9263       (arg1)->SetY(arg2);
9264     } catch (std::out_of_range& e) {
9265       {
9266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9267       };
9268     } catch (std::exception& e) {
9269       {
9270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9271       };
9272     } catch (Dali::DaliException e) {
9273       {
9274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9275       };
9276     } catch (...) {
9277       {
9278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9279       };
9280     }
9281   }
9282
9283 }
9284
9285
9286 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9287   unsigned short jresult ;
9288   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9289   uint16_t result;
9290
9291   arg1 = (Dali::Uint16Pair *)jarg1;
9292   {
9293     try {
9294       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9295     } catch (std::out_of_range& e) {
9296       {
9297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9298       };
9299     } catch (std::exception& e) {
9300       {
9301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9302       };
9303     } catch (Dali::DaliException e) {
9304       {
9305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9306       };
9307     } catch (...) {
9308       {
9309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9310       };
9311     }
9312   }
9313
9314   jresult = result;
9315   return jresult;
9316 }
9317
9318
9319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9320   void * jresult ;
9321   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9322   Dali::Uint16Pair *arg2 = 0 ;
9323   Dali::Uint16Pair *result = 0 ;
9324
9325   arg1 = (Dali::Uint16Pair *)jarg1;
9326   arg2 = (Dali::Uint16Pair *)jarg2;
9327   if (!arg2) {
9328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9329     return 0;
9330   }
9331   {
9332     try {
9333       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9334     } catch (std::out_of_range& e) {
9335       {
9336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9337       };
9338     } catch (std::exception& e) {
9339       {
9340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9341       };
9342     } catch (Dali::DaliException e) {
9343       {
9344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9345       };
9346     } catch (...) {
9347       {
9348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9349       };
9350     }
9351   }
9352
9353   jresult = (void *)result;
9354   return jresult;
9355 }
9356
9357
9358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9359   unsigned int jresult ;
9360   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9361   Dali::Uint16Pair *arg2 = 0 ;
9362   bool result;
9363
9364   arg1 = (Dali::Uint16Pair *)jarg1;
9365   arg2 = (Dali::Uint16Pair *)jarg2;
9366   if (!arg2) {
9367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9368     return 0;
9369   }
9370   {
9371     try {
9372       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9373     } catch (std::out_of_range& e) {
9374       {
9375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9376       };
9377     } catch (std::exception& e) {
9378       {
9379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9380       };
9381     } catch (Dali::DaliException e) {
9382       {
9383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9384       };
9385     } catch (...) {
9386       {
9387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9388       };
9389     }
9390   }
9391
9392   jresult = result;
9393   return jresult;
9394 }
9395
9396
9397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9398   unsigned int jresult ;
9399   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9400   Dali::Uint16Pair *arg2 = 0 ;
9401   bool result;
9402
9403   arg1 = (Dali::Uint16Pair *)jarg1;
9404   arg2 = (Dali::Uint16Pair *)jarg2;
9405   if (!arg2) {
9406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9407     return 0;
9408   }
9409   {
9410     try {
9411       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9412     } catch (std::out_of_range& e) {
9413       {
9414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9415       };
9416     } catch (std::exception& e) {
9417       {
9418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9419       };
9420     } catch (Dali::DaliException e) {
9421       {
9422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9423       };
9424     } catch (...) {
9425       {
9426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9427       };
9428     }
9429   }
9430
9431   jresult = result;
9432   return jresult;
9433 }
9434
9435
9436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9437   unsigned int jresult ;
9438   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9439   Dali::Uint16Pair *arg2 = 0 ;
9440   bool result;
9441
9442   arg1 = (Dali::Uint16Pair *)jarg1;
9443   arg2 = (Dali::Uint16Pair *)jarg2;
9444   if (!arg2) {
9445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9446     return 0;
9447   }
9448   {
9449     try {
9450       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9451     } catch (std::out_of_range& e) {
9452       {
9453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9454       };
9455     } catch (std::exception& e) {
9456       {
9457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9458       };
9459     } catch (Dali::DaliException e) {
9460       {
9461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9462       };
9463     } catch (...) {
9464       {
9465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9466       };
9467     }
9468   }
9469
9470   jresult = result;
9471   return jresult;
9472 }
9473
9474
9475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9476   unsigned int jresult ;
9477   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9478   Dali::Uint16Pair *arg2 = 0 ;
9479   bool result;
9480
9481   arg1 = (Dali::Uint16Pair *)jarg1;
9482   arg2 = (Dali::Uint16Pair *)jarg2;
9483   if (!arg2) {
9484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9485     return 0;
9486   }
9487   {
9488     try {
9489       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9490     } catch (std::out_of_range& e) {
9491       {
9492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9493       };
9494     } catch (std::exception& e) {
9495       {
9496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9497       };
9498     } catch (Dali::DaliException e) {
9499       {
9500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9501       };
9502     } catch (...) {
9503       {
9504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9505       };
9506     }
9507   }
9508
9509   jresult = result;
9510   return jresult;
9511 }
9512
9513
9514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9515   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9516
9517   arg1 = (Dali::Uint16Pair *)jarg1;
9518   {
9519     try {
9520       delete arg1;
9521     } catch (std::out_of_range& e) {
9522       {
9523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9524       };
9525     } catch (std::exception& e) {
9526       {
9527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9528       };
9529     } catch (Dali::DaliException e) {
9530       {
9531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9532       };
9533     } catch (...) {
9534       {
9535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9536       };
9537     }
9538   }
9539
9540 }
9541
9542
9543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9544   void * jresult ;
9545   Dali::Degree *result = 0 ;
9546
9547   {
9548     try {
9549       result = (Dali::Degree *)new Dali::Degree();
9550     } catch (std::out_of_range& e) {
9551       {
9552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9553       };
9554     } catch (std::exception& e) {
9555       {
9556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9557       };
9558     } catch (Dali::DaliException e) {
9559       {
9560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9561       };
9562     } catch (...) {
9563       {
9564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9565       };
9566     }
9567   }
9568
9569   jresult = (void *)result;
9570   return jresult;
9571 }
9572
9573
9574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9575   void * jresult ;
9576   float arg1 ;
9577   Dali::Degree *result = 0 ;
9578
9579   arg1 = (float)jarg1;
9580   {
9581     try {
9582       result = (Dali::Degree *)new Dali::Degree(arg1);
9583     } catch (std::out_of_range& e) {
9584       {
9585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9586       };
9587     } catch (std::exception& e) {
9588       {
9589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9590       };
9591     } catch (Dali::DaliException e) {
9592       {
9593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9594       };
9595     } catch (...) {
9596       {
9597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9598       };
9599     }
9600   }
9601
9602   jresult = (void *)result;
9603   return jresult;
9604 }
9605
9606
9607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9608   void * jresult ;
9609   Dali::Radian arg1 ;
9610   Dali::Radian *argp1 ;
9611   Dali::Degree *result = 0 ;
9612
9613   argp1 = (Dali::Radian *)jarg1;
9614   if (!argp1) {
9615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9616     return 0;
9617   }
9618   arg1 = *argp1;
9619   {
9620     try {
9621       result = (Dali::Degree *)new Dali::Degree(arg1);
9622     } catch (std::out_of_range& e) {
9623       {
9624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9625       };
9626     } catch (std::exception& e) {
9627       {
9628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9629       };
9630     } catch (Dali::DaliException e) {
9631       {
9632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9633       };
9634     } catch (...) {
9635       {
9636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9637       };
9638     }
9639   }
9640
9641   jresult = (void *)result;
9642   return jresult;
9643 }
9644
9645
9646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9647   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9648   float arg2 ;
9649
9650   arg1 = (Dali::Degree *)jarg1;
9651   arg2 = (float)jarg2;
9652   if (arg1) (arg1)->degree = arg2;
9653 }
9654
9655
9656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9657   float jresult ;
9658   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9659   float result;
9660
9661   arg1 = (Dali::Degree *)jarg1;
9662   result = (float) ((arg1)->degree);
9663   jresult = result;
9664   return jresult;
9665 }
9666
9667
9668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9669   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9670
9671   arg1 = (Dali::Degree *)jarg1;
9672   {
9673     try {
9674       delete arg1;
9675     } catch (std::out_of_range& e) {
9676       {
9677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9678       };
9679     } catch (std::exception& e) {
9680       {
9681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9682       };
9683     } catch (Dali::DaliException e) {
9684       {
9685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9686       };
9687     } catch (...) {
9688       {
9689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9690       };
9691     }
9692   }
9693
9694 }
9695
9696
9697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9698   void * jresult ;
9699   Dali::Radian *result = 0 ;
9700
9701   result = (Dali::Radian *)&Dali::ANGLE_360;
9702   jresult = (void *)result;
9703   return jresult;
9704 }
9705
9706
9707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9708   void * jresult ;
9709   Dali::Radian *result = 0 ;
9710
9711   result = (Dali::Radian *)&Dali::ANGLE_315;
9712   jresult = (void *)result;
9713   return jresult;
9714 }
9715
9716
9717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9718   void * jresult ;
9719   Dali::Radian *result = 0 ;
9720
9721   result = (Dali::Radian *)&Dali::ANGLE_270;
9722   jresult = (void *)result;
9723   return jresult;
9724 }
9725
9726
9727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9728   void * jresult ;
9729   Dali::Radian *result = 0 ;
9730
9731   result = (Dali::Radian *)&Dali::ANGLE_225;
9732   jresult = (void *)result;
9733   return jresult;
9734 }
9735
9736
9737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9738   void * jresult ;
9739   Dali::Radian *result = 0 ;
9740
9741   result = (Dali::Radian *)&Dali::ANGLE_180;
9742   jresult = (void *)result;
9743   return jresult;
9744 }
9745
9746
9747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9748   void * jresult ;
9749   Dali::Radian *result = 0 ;
9750
9751   result = (Dali::Radian *)&Dali::ANGLE_135;
9752   jresult = (void *)result;
9753   return jresult;
9754 }
9755
9756
9757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9758   void * jresult ;
9759   Dali::Radian *result = 0 ;
9760
9761   result = (Dali::Radian *)&Dali::ANGLE_120;
9762   jresult = (void *)result;
9763   return jresult;
9764 }
9765
9766
9767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9768   void * jresult ;
9769   Dali::Radian *result = 0 ;
9770
9771   result = (Dali::Radian *)&Dali::ANGLE_90;
9772   jresult = (void *)result;
9773   return jresult;
9774 }
9775
9776
9777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9778   void * jresult ;
9779   Dali::Radian *result = 0 ;
9780
9781   result = (Dali::Radian *)&Dali::ANGLE_60;
9782   jresult = (void *)result;
9783   return jresult;
9784 }
9785
9786
9787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9788   void * jresult ;
9789   Dali::Radian *result = 0 ;
9790
9791   result = (Dali::Radian *)&Dali::ANGLE_45;
9792   jresult = (void *)result;
9793   return jresult;
9794 }
9795
9796
9797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9798   void * jresult ;
9799   Dali::Radian *result = 0 ;
9800
9801   result = (Dali::Radian *)&Dali::ANGLE_30;
9802   jresult = (void *)result;
9803   return jresult;
9804 }
9805
9806
9807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9808   void * jresult ;
9809   Dali::Radian *result = 0 ;
9810
9811   result = (Dali::Radian *)&Dali::ANGLE_0;
9812   jresult = (void *)result;
9813   return jresult;
9814 }
9815
9816
9817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9818   unsigned int jresult ;
9819   Dali::Degree *arg1 = 0 ;
9820   Dali::Degree *arg2 = 0 ;
9821   bool result;
9822
9823   arg1 = (Dali::Degree *)jarg1;
9824   if (!arg1) {
9825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9826     return 0;
9827   }
9828   arg2 = (Dali::Degree *)jarg2;
9829   if (!arg2) {
9830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9831     return 0;
9832   }
9833   {
9834     try {
9835       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9836     } catch (std::out_of_range& e) {
9837       {
9838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (std::exception& e) {
9841       {
9842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9843       };
9844     } catch (Dali::DaliException e) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9847       };
9848     } catch (...) {
9849       {
9850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9851       };
9852     }
9853   }
9854
9855   jresult = result;
9856   return jresult;
9857 }
9858
9859
9860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9861   unsigned int jresult ;
9862   Dali::Degree *arg1 = 0 ;
9863   Dali::Degree *arg2 = 0 ;
9864   bool result;
9865
9866   arg1 = (Dali::Degree *)jarg1;
9867   if (!arg1) {
9868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9869     return 0;
9870   }
9871   arg2 = (Dali::Degree *)jarg2;
9872   if (!arg2) {
9873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9874     return 0;
9875   }
9876   {
9877     try {
9878       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9879     } catch (std::out_of_range& e) {
9880       {
9881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9882       };
9883     } catch (std::exception& e) {
9884       {
9885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9886       };
9887     } catch (Dali::DaliException e) {
9888       {
9889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9890       };
9891     } catch (...) {
9892       {
9893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9894       };
9895     }
9896   }
9897
9898   jresult = result;
9899   return jresult;
9900 }
9901
9902
9903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9904   void * jresult ;
9905   Dali::Degree arg1 ;
9906   float arg2 ;
9907   float arg3 ;
9908   Dali::Degree *argp1 ;
9909   Dali::Degree result;
9910
9911   argp1 = (Dali::Degree *)jarg1;
9912   if (!argp1) {
9913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9914     return 0;
9915   }
9916   arg1 = *argp1;
9917   arg2 = (float)jarg2;
9918   arg3 = (float)jarg3;
9919   {
9920     try {
9921       result = Dali::Clamp(arg1,arg2,arg3);
9922     } catch (std::out_of_range& e) {
9923       {
9924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9925       };
9926     } catch (std::exception& e) {
9927       {
9928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9929       };
9930     } catch (Dali::DaliException e) {
9931       {
9932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9933       };
9934     } catch (...) {
9935       {
9936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9937       };
9938     }
9939   }
9940
9941   jresult = new Dali::Degree((const Dali::Degree &)result);
9942   return jresult;
9943 }
9944
9945
9946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9947   void * jresult ;
9948   Dali::Radian *result = 0 ;
9949
9950   {
9951     try {
9952       result = (Dali::Radian *)new Dali::Radian();
9953     } catch (std::out_of_range& e) {
9954       {
9955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9956       };
9957     } catch (std::exception& e) {
9958       {
9959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9960       };
9961     } catch (Dali::DaliException e) {
9962       {
9963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9964       };
9965     } catch (...) {
9966       {
9967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9968       };
9969     }
9970   }
9971
9972   jresult = (void *)result;
9973   return jresult;
9974 }
9975
9976
9977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9978   void * jresult ;
9979   float arg1 ;
9980   Dali::Radian *result = 0 ;
9981
9982   arg1 = (float)jarg1;
9983   {
9984     try {
9985       result = (Dali::Radian *)new Dali::Radian(arg1);
9986     } catch (std::out_of_range& e) {
9987       {
9988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9989       };
9990     } catch (std::exception& e) {
9991       {
9992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9993       };
9994     } catch (Dali::DaliException e) {
9995       {
9996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9997       };
9998     } catch (...) {
9999       {
10000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10001       };
10002     }
10003   }
10004
10005   jresult = (void *)result;
10006   return jresult;
10007 }
10008
10009
10010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10011   void * jresult ;
10012   Dali::Degree arg1 ;
10013   Dali::Degree *argp1 ;
10014   Dali::Radian *result = 0 ;
10015
10016   argp1 = (Dali::Degree *)jarg1;
10017   if (!argp1) {
10018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10019     return 0;
10020   }
10021   arg1 = *argp1;
10022   {
10023     try {
10024       result = (Dali::Radian *)new Dali::Radian(arg1);
10025     } catch (std::out_of_range& e) {
10026       {
10027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10028       };
10029     } catch (std::exception& e) {
10030       {
10031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10032       };
10033     } catch (Dali::DaliException e) {
10034       {
10035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10036       };
10037     } catch (...) {
10038       {
10039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10040       };
10041     }
10042   }
10043
10044   jresult = (void *)result;
10045   return jresult;
10046 }
10047
10048
10049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10050   void * jresult ;
10051   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10052   float arg2 ;
10053   Dali::Radian *result = 0 ;
10054
10055   arg1 = (Dali::Radian *)jarg1;
10056   arg2 = (float)jarg2;
10057   {
10058     try {
10059       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10060     } catch (std::out_of_range& e) {
10061       {
10062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10063       };
10064     } catch (std::exception& e) {
10065       {
10066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10067       };
10068     } catch (Dali::DaliException e) {
10069       {
10070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10071       };
10072     } catch (...) {
10073       {
10074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10075       };
10076     }
10077   }
10078
10079   jresult = (void *)result;
10080   return jresult;
10081 }
10082
10083
10084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10085   void * jresult ;
10086   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10087   Dali::Degree arg2 ;
10088   Dali::Degree *argp2 ;
10089   Dali::Radian *result = 0 ;
10090
10091   arg1 = (Dali::Radian *)jarg1;
10092   argp2 = (Dali::Degree *)jarg2;
10093   if (!argp2) {
10094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10095     return 0;
10096   }
10097   arg2 = *argp2;
10098   {
10099     try {
10100       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10101     } catch (std::out_of_range& e) {
10102       {
10103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10104       };
10105     } catch (std::exception& e) {
10106       {
10107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10108       };
10109     } catch (Dali::DaliException e) {
10110       {
10111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10112       };
10113     } catch (...) {
10114       {
10115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10116       };
10117     }
10118   }
10119
10120   jresult = (void *)result;
10121   return jresult;
10122 }
10123
10124
10125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10126   float jresult ;
10127   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10128   float result;
10129
10130   arg1 = (Dali::Radian *)jarg1;
10131   {
10132     try {
10133       result = (float)((Dali::Radian const *)arg1)->operator float();
10134     } catch (std::out_of_range& e) {
10135       {
10136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10137       };
10138     } catch (std::exception& e) {
10139       {
10140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10141       };
10142     } catch (Dali::DaliException e) {
10143       {
10144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10145       };
10146     } catch (...) {
10147       {
10148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10149       };
10150     }
10151   }
10152
10153   jresult = result;
10154   return jresult;
10155 }
10156
10157
10158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10159   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10160   float arg2 ;
10161
10162   arg1 = (Dali::Radian *)jarg1;
10163   arg2 = (float)jarg2;
10164   if (arg1) (arg1)->radian = arg2;
10165 }
10166
10167
10168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10169   float jresult ;
10170   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10171   float result;
10172
10173   arg1 = (Dali::Radian *)jarg1;
10174   result = (float) ((arg1)->radian);
10175   jresult = result;
10176   return jresult;
10177 }
10178
10179
10180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10181   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10182
10183   arg1 = (Dali::Radian *)jarg1;
10184   {
10185     try {
10186       delete arg1;
10187     } catch (std::out_of_range& e) {
10188       {
10189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10190       };
10191     } catch (std::exception& e) {
10192       {
10193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10194       };
10195     } catch (Dali::DaliException e) {
10196       {
10197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10198       };
10199     } catch (...) {
10200       {
10201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10202       };
10203     }
10204   }
10205
10206 }
10207
10208
10209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10210   unsigned int jresult ;
10211   Dali::Radian arg1 ;
10212   Dali::Radian arg2 ;
10213   Dali::Radian *argp1 ;
10214   Dali::Radian *argp2 ;
10215   bool result;
10216
10217   argp1 = (Dali::Radian *)jarg1;
10218   if (!argp1) {
10219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10220     return 0;
10221   }
10222   arg1 = *argp1;
10223   argp2 = (Dali::Radian *)jarg2;
10224   if (!argp2) {
10225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10226     return 0;
10227   }
10228   arg2 = *argp2;
10229   {
10230     try {
10231       result = (bool)Dali::operator ==(arg1,arg2);
10232     } catch (std::out_of_range& e) {
10233       {
10234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (std::exception& e) {
10237       {
10238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10239       };
10240     } catch (Dali::DaliException e) {
10241       {
10242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10243       };
10244     } catch (...) {
10245       {
10246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10247       };
10248     }
10249   }
10250
10251   jresult = result;
10252   return jresult;
10253 }
10254
10255
10256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10257   unsigned int jresult ;
10258   Dali::Radian arg1 ;
10259   Dali::Radian arg2 ;
10260   Dali::Radian *argp1 ;
10261   Dali::Radian *argp2 ;
10262   bool result;
10263
10264   argp1 = (Dali::Radian *)jarg1;
10265   if (!argp1) {
10266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10267     return 0;
10268   }
10269   arg1 = *argp1;
10270   argp2 = (Dali::Radian *)jarg2;
10271   if (!argp2) {
10272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10273     return 0;
10274   }
10275   arg2 = *argp2;
10276   {
10277     try {
10278       result = (bool)Dali::operator !=(arg1,arg2);
10279     } catch (std::out_of_range& e) {
10280       {
10281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (std::exception& e) {
10284       {
10285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10286       };
10287     } catch (Dali::DaliException e) {
10288       {
10289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10290       };
10291     } catch (...) {
10292       {
10293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10294       };
10295     }
10296   }
10297
10298   jresult = result;
10299   return jresult;
10300 }
10301
10302
10303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10304   unsigned int jresult ;
10305   Dali::Radian arg1 ;
10306   Dali::Degree arg2 ;
10307   Dali::Radian *argp1 ;
10308   Dali::Degree *argp2 ;
10309   bool result;
10310
10311   argp1 = (Dali::Radian *)jarg1;
10312   if (!argp1) {
10313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10314     return 0;
10315   }
10316   arg1 = *argp1;
10317   argp2 = (Dali::Degree *)jarg2;
10318   if (!argp2) {
10319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10320     return 0;
10321   }
10322   arg2 = *argp2;
10323   {
10324     try {
10325       result = (bool)Dali::operator ==(arg1,arg2);
10326     } catch (std::out_of_range& e) {
10327       {
10328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (std::exception& e) {
10331       {
10332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10333       };
10334     } catch (Dali::DaliException e) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10337       };
10338     } catch (...) {
10339       {
10340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10341       };
10342     }
10343   }
10344
10345   jresult = result;
10346   return jresult;
10347 }
10348
10349
10350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10351   unsigned int jresult ;
10352   Dali::Radian arg1 ;
10353   Dali::Degree arg2 ;
10354   Dali::Radian *argp1 ;
10355   Dali::Degree *argp2 ;
10356   bool result;
10357
10358   argp1 = (Dali::Radian *)jarg1;
10359   if (!argp1) {
10360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10361     return 0;
10362   }
10363   arg1 = *argp1;
10364   argp2 = (Dali::Degree *)jarg2;
10365   if (!argp2) {
10366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10367     return 0;
10368   }
10369   arg2 = *argp2;
10370   {
10371     try {
10372       result = (bool)Dali::operator !=(arg1,arg2);
10373     } catch (std::out_of_range& e) {
10374       {
10375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (std::exception& e) {
10378       {
10379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10380       };
10381     } catch (Dali::DaliException e) {
10382       {
10383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10384       };
10385     } catch (...) {
10386       {
10387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10388       };
10389     }
10390   }
10391
10392   jresult = result;
10393   return jresult;
10394 }
10395
10396
10397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10398   unsigned int jresult ;
10399   Dali::Degree arg1 ;
10400   Dali::Radian arg2 ;
10401   Dali::Degree *argp1 ;
10402   Dali::Radian *argp2 ;
10403   bool result;
10404
10405   argp1 = (Dali::Degree *)jarg1;
10406   if (!argp1) {
10407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10408     return 0;
10409   }
10410   arg1 = *argp1;
10411   argp2 = (Dali::Radian *)jarg2;
10412   if (!argp2) {
10413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10414     return 0;
10415   }
10416   arg2 = *argp2;
10417   {
10418     try {
10419       result = (bool)Dali::operator ==(arg1,arg2);
10420     } catch (std::out_of_range& e) {
10421       {
10422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (std::exception& e) {
10425       {
10426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10427       };
10428     } catch (Dali::DaliException e) {
10429       {
10430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10431       };
10432     } catch (...) {
10433       {
10434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10435       };
10436     }
10437   }
10438
10439   jresult = result;
10440   return jresult;
10441 }
10442
10443
10444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10445   unsigned int jresult ;
10446   Dali::Degree arg1 ;
10447   Dali::Radian arg2 ;
10448   Dali::Degree *argp1 ;
10449   Dali::Radian *argp2 ;
10450   bool result;
10451
10452   argp1 = (Dali::Degree *)jarg1;
10453   if (!argp1) {
10454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10455     return 0;
10456   }
10457   arg1 = *argp1;
10458   argp2 = (Dali::Radian *)jarg2;
10459   if (!argp2) {
10460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10461     return 0;
10462   }
10463   arg2 = *argp2;
10464   {
10465     try {
10466       result = (bool)Dali::operator !=(arg1,arg2);
10467     } catch (std::out_of_range& e) {
10468       {
10469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10470       };
10471     } catch (std::exception& e) {
10472       {
10473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10474       };
10475     } catch (Dali::DaliException e) {
10476       {
10477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10478       };
10479     } catch (...) {
10480       {
10481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10482       };
10483     }
10484   }
10485
10486   jresult = result;
10487   return jresult;
10488 }
10489
10490
10491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10492   unsigned int jresult ;
10493   Dali::Radian arg1 ;
10494   Dali::Radian arg2 ;
10495   Dali::Radian *argp1 ;
10496   Dali::Radian *argp2 ;
10497   bool result;
10498
10499   argp1 = (Dali::Radian *)jarg1;
10500   if (!argp1) {
10501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10502     return 0;
10503   }
10504   arg1 = *argp1;
10505   argp2 = (Dali::Radian *)jarg2;
10506   if (!argp2) {
10507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10508     return 0;
10509   }
10510   arg2 = *argp2;
10511   {
10512     try {
10513       result = (bool)Dali::operator >(arg1,arg2);
10514     } catch (std::out_of_range& e) {
10515       {
10516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (std::exception& e) {
10519       {
10520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10521       };
10522     } catch (Dali::DaliException e) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10525       };
10526     } catch (...) {
10527       {
10528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10529       };
10530     }
10531   }
10532
10533   jresult = result;
10534   return jresult;
10535 }
10536
10537
10538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10539   unsigned int jresult ;
10540   Dali::Radian arg1 ;
10541   Dali::Degree arg2 ;
10542   Dali::Radian *argp1 ;
10543   Dali::Degree *argp2 ;
10544   bool result;
10545
10546   argp1 = (Dali::Radian *)jarg1;
10547   if (!argp1) {
10548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10549     return 0;
10550   }
10551   arg1 = *argp1;
10552   argp2 = (Dali::Degree *)jarg2;
10553   if (!argp2) {
10554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10555     return 0;
10556   }
10557   arg2 = *argp2;
10558   {
10559     try {
10560       result = (bool)Dali::operator >(arg1,arg2);
10561     } catch (std::out_of_range& e) {
10562       {
10563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10564       };
10565     } catch (std::exception& e) {
10566       {
10567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10568       };
10569     } catch (Dali::DaliException e) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10572       };
10573     } catch (...) {
10574       {
10575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10576       };
10577     }
10578   }
10579
10580   jresult = result;
10581   return jresult;
10582 }
10583
10584
10585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10586   unsigned int jresult ;
10587   Dali::Degree arg1 ;
10588   Dali::Radian arg2 ;
10589   Dali::Degree *argp1 ;
10590   Dali::Radian *argp2 ;
10591   bool result;
10592
10593   argp1 = (Dali::Degree *)jarg1;
10594   if (!argp1) {
10595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10596     return 0;
10597   }
10598   arg1 = *argp1;
10599   argp2 = (Dali::Radian *)jarg2;
10600   if (!argp2) {
10601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10602     return 0;
10603   }
10604   arg2 = *argp2;
10605   {
10606     try {
10607       result = (bool)Dali::operator >(arg1,arg2);
10608     } catch (std::out_of_range& e) {
10609       {
10610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10611       };
10612     } catch (std::exception& e) {
10613       {
10614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10615       };
10616     } catch (Dali::DaliException e) {
10617       {
10618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10619       };
10620     } catch (...) {
10621       {
10622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10623       };
10624     }
10625   }
10626
10627   jresult = result;
10628   return jresult;
10629 }
10630
10631
10632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10633   unsigned int jresult ;
10634   Dali::Radian arg1 ;
10635   Dali::Radian arg2 ;
10636   Dali::Radian *argp1 ;
10637   Dali::Radian *argp2 ;
10638   bool result;
10639
10640   argp1 = (Dali::Radian *)jarg1;
10641   if (!argp1) {
10642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10643     return 0;
10644   }
10645   arg1 = *argp1;
10646   argp2 = (Dali::Radian *)jarg2;
10647   if (!argp2) {
10648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10649     return 0;
10650   }
10651   arg2 = *argp2;
10652   {
10653     try {
10654       result = (bool)Dali::operator <(arg1,arg2);
10655     } catch (std::out_of_range& e) {
10656       {
10657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (std::exception& e) {
10660       {
10661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10662       };
10663     } catch (Dali::DaliException e) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10666       };
10667     } catch (...) {
10668       {
10669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10670       };
10671     }
10672   }
10673
10674   jresult = result;
10675   return jresult;
10676 }
10677
10678
10679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10680   unsigned int jresult ;
10681   Dali::Radian arg1 ;
10682   Dali::Degree arg2 ;
10683   Dali::Radian *argp1 ;
10684   Dali::Degree *argp2 ;
10685   bool result;
10686
10687   argp1 = (Dali::Radian *)jarg1;
10688   if (!argp1) {
10689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10690     return 0;
10691   }
10692   arg1 = *argp1;
10693   argp2 = (Dali::Degree *)jarg2;
10694   if (!argp2) {
10695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10696     return 0;
10697   }
10698   arg2 = *argp2;
10699   {
10700     try {
10701       result = (bool)Dali::operator <(arg1,arg2);
10702     } catch (std::out_of_range& e) {
10703       {
10704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10705       };
10706     } catch (std::exception& e) {
10707       {
10708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10709       };
10710     } catch (Dali::DaliException e) {
10711       {
10712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10713       };
10714     } catch (...) {
10715       {
10716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10717       };
10718     }
10719   }
10720
10721   jresult = result;
10722   return jresult;
10723 }
10724
10725
10726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10727   unsigned int jresult ;
10728   Dali::Degree arg1 ;
10729   Dali::Radian arg2 ;
10730   Dali::Degree *argp1 ;
10731   Dali::Radian *argp2 ;
10732   bool result;
10733
10734   argp1 = (Dali::Degree *)jarg1;
10735   if (!argp1) {
10736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10737     return 0;
10738   }
10739   arg1 = *argp1;
10740   argp2 = (Dali::Radian *)jarg2;
10741   if (!argp2) {
10742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10743     return 0;
10744   }
10745   arg2 = *argp2;
10746   {
10747     try {
10748       result = (bool)Dali::operator <(arg1,arg2);
10749     } catch (std::out_of_range& e) {
10750       {
10751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10752       };
10753     } catch (std::exception& e) {
10754       {
10755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10756       };
10757     } catch (Dali::DaliException e) {
10758       {
10759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10760       };
10761     } catch (...) {
10762       {
10763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10764       };
10765     }
10766   }
10767
10768   jresult = result;
10769   return jresult;
10770 }
10771
10772
10773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10774   void * jresult ;
10775   Dali::Radian arg1 ;
10776   float arg2 ;
10777   Dali::Radian *argp1 ;
10778   Dali::Radian result;
10779
10780   argp1 = (Dali::Radian *)jarg1;
10781   if (!argp1) {
10782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10783     return 0;
10784   }
10785   arg1 = *argp1;
10786   arg2 = (float)jarg2;
10787   {
10788     try {
10789       result = Dali::operator *(arg1,arg2);
10790     } catch (std::out_of_range& e) {
10791       {
10792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10793       };
10794     } catch (std::exception& e) {
10795       {
10796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10797       };
10798     } catch (Dali::DaliException e) {
10799       {
10800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10801       };
10802     } catch (...) {
10803       {
10804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10805       };
10806     }
10807   }
10808
10809   jresult = new Dali::Radian((const Dali::Radian &)result);
10810   return jresult;
10811 }
10812
10813
10814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10815   void * jresult ;
10816   Dali::Radian arg1 ;
10817   Dali::Radian *argp1 ;
10818   Dali::Radian result;
10819
10820   argp1 = (Dali::Radian *)jarg1;
10821   if (!argp1) {
10822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10823     return 0;
10824   }
10825   arg1 = *argp1;
10826   {
10827     try {
10828       result = Dali::operator -(arg1);
10829     } catch (std::out_of_range& e) {
10830       {
10831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (std::exception& e) {
10834       {
10835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10836       };
10837     } catch (Dali::DaliException e) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10840       };
10841     } catch (...) {
10842       {
10843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10844       };
10845     }
10846   }
10847
10848   jresult = new Dali::Radian((const Dali::Radian &)result);
10849   return jresult;
10850 }
10851
10852
10853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10854   void * jresult ;
10855   Dali::Radian arg1 ;
10856   float arg2 ;
10857   float arg3 ;
10858   Dali::Radian *argp1 ;
10859   Dali::Radian result;
10860
10861   argp1 = (Dali::Radian *)jarg1;
10862   if (!argp1) {
10863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10864     return 0;
10865   }
10866   arg1 = *argp1;
10867   arg2 = (float)jarg2;
10868   arg3 = (float)jarg3;
10869   {
10870     try {
10871       result = Dali::Clamp(arg1,arg2,arg3);
10872     } catch (std::out_of_range& e) {
10873       {
10874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10875       };
10876     } catch (std::exception& e) {
10877       {
10878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10879       };
10880     } catch (Dali::DaliException e) {
10881       {
10882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10883       };
10884     } catch (...) {
10885       {
10886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10887       };
10888     }
10889   }
10890
10891   jresult = new Dali::Radian((const Dali::Radian &)result);
10892   return jresult;
10893 }
10894
10895
10896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10897   void * jresult ;
10898   Dali::Quaternion *result = 0 ;
10899
10900   {
10901     try {
10902       result = (Dali::Quaternion *)new Dali::Quaternion();
10903     } catch (std::out_of_range& e) {
10904       {
10905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10906       };
10907     } catch (std::exception& e) {
10908       {
10909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10910       };
10911     } catch (Dali::DaliException e) {
10912       {
10913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10914       };
10915     } catch (...) {
10916       {
10917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10918       };
10919     }
10920   }
10921
10922   jresult = (void *)result;
10923   return jresult;
10924 }
10925
10926
10927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10928   void * jresult ;
10929   Dali::Radian arg1 ;
10930   Dali::Vector3 *arg2 = 0 ;
10931   Dali::Radian *argp1 ;
10932   Dali::Quaternion *result = 0 ;
10933
10934   argp1 = (Dali::Radian *)jarg1;
10935   if (!argp1) {
10936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10937     return 0;
10938   }
10939   arg1 = *argp1;
10940   arg2 = (Dali::Vector3 *)jarg2;
10941   if (!arg2) {
10942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10943     return 0;
10944   }
10945   {
10946     try {
10947       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10948     } catch (std::out_of_range& e) {
10949       {
10950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10951       };
10952     } catch (std::exception& e) {
10953       {
10954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10955       };
10956     } catch (Dali::DaliException e) {
10957       {
10958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10959       };
10960     } catch (...) {
10961       {
10962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10963       };
10964     }
10965   }
10966
10967   jresult = (void *)result;
10968   return jresult;
10969 }
10970
10971
10972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10973   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10974
10975   arg1 = (Dali::Quaternion *)jarg1;
10976   {
10977     try {
10978       delete arg1;
10979     } catch (std::out_of_range& e) {
10980       {
10981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10982       };
10983     } catch (std::exception& e) {
10984       {
10985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10986       };
10987     } catch (Dali::DaliException e) {
10988       {
10989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10990       };
10991     } catch (...) {
10992       {
10993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10994       };
10995     }
10996   }
10997
10998 }
10999
11000
11001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11002   void * jresult ;
11003   Dali::Quaternion *result = 0 ;
11004
11005   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11006   jresult = (void *)result;
11007   return jresult;
11008 }
11009
11010
11011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11012   unsigned int jresult ;
11013   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11014   bool result;
11015
11016   arg1 = (Dali::Quaternion *)jarg1;
11017   {
11018     try {
11019       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11020     } catch (std::out_of_range& e) {
11021       {
11022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11023       };
11024     } catch (std::exception& e) {
11025       {
11026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11027       };
11028     } catch (Dali::DaliException e) {
11029       {
11030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11031       };
11032     } catch (...) {
11033       {
11034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11035       };
11036     }
11037   }
11038
11039   jresult = result;
11040   return jresult;
11041 }
11042
11043
11044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11045   unsigned int jresult ;
11046   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11047   Dali::Vector3 *arg2 = 0 ;
11048   Dali::Radian *arg3 = 0 ;
11049   bool result;
11050
11051   arg1 = (Dali::Quaternion *)jarg1;
11052   arg2 = (Dali::Vector3 *)jarg2;
11053   if (!arg2) {
11054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11055     return 0;
11056   }
11057   arg3 = (Dali::Radian *)jarg3;
11058   if (!arg3) {
11059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11060     return 0;
11061   }
11062   {
11063     try {
11064       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11065     } catch (std::out_of_range& e) {
11066       {
11067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11068       };
11069     } catch (std::exception& e) {
11070       {
11071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11072       };
11073     } catch (Dali::DaliException e) {
11074       {
11075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11076       };
11077     } catch (...) {
11078       {
11079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11080       };
11081     }
11082   }
11083
11084   jresult = result;
11085   return jresult;
11086 }
11087
11088
11089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11090   void * jresult ;
11091   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11092   Dali::Quaternion *arg2 = 0 ;
11093   Dali::Quaternion result;
11094
11095   arg1 = (Dali::Quaternion *)jarg1;
11096   arg2 = (Dali::Quaternion *)jarg2;
11097   if (!arg2) {
11098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11099     return 0;
11100   }
11101   {
11102     try {
11103       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11104     } catch (std::out_of_range& e) {
11105       {
11106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11107       };
11108     } catch (std::exception& e) {
11109       {
11110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11111       };
11112     } catch (Dali::DaliException e) {
11113       {
11114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11115       };
11116     } catch (...) {
11117       {
11118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11119       };
11120     }
11121   }
11122
11123   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11124   return jresult;
11125 }
11126
11127
11128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11129   void * jresult ;
11130   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11131   Dali::Quaternion *arg2 = 0 ;
11132   Dali::Quaternion result;
11133
11134   arg1 = (Dali::Quaternion *)jarg1;
11135   arg2 = (Dali::Quaternion *)jarg2;
11136   if (!arg2) {
11137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11138     return 0;
11139   }
11140   {
11141     try {
11142       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11143     } catch (std::out_of_range& e) {
11144       {
11145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11146       };
11147     } catch (std::exception& e) {
11148       {
11149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11150       };
11151     } catch (Dali::DaliException e) {
11152       {
11153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11154       };
11155     } catch (...) {
11156       {
11157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11158       };
11159     }
11160   }
11161
11162   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11163   return jresult;
11164 }
11165
11166
11167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11168   void * jresult ;
11169   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11170   Dali::Quaternion *arg2 = 0 ;
11171   Dali::Quaternion result;
11172
11173   arg1 = (Dali::Quaternion *)jarg1;
11174   arg2 = (Dali::Quaternion *)jarg2;
11175   if (!arg2) {
11176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11177     return 0;
11178   }
11179   {
11180     try {
11181       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11182     } catch (std::out_of_range& e) {
11183       {
11184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11185       };
11186     } catch (std::exception& e) {
11187       {
11188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11189       };
11190     } catch (Dali::DaliException e) {
11191       {
11192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11193       };
11194     } catch (...) {
11195       {
11196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11197       };
11198     }
11199   }
11200
11201   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11202   return jresult;
11203 }
11204
11205
11206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11207   void * jresult ;
11208   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11209   Dali::Vector3 *arg2 = 0 ;
11210   Dali::Vector3 result;
11211
11212   arg1 = (Dali::Quaternion *)jarg1;
11213   arg2 = (Dali::Vector3 *)jarg2;
11214   if (!arg2) {
11215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11216     return 0;
11217   }
11218   {
11219     try {
11220       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11221     } catch (std::out_of_range& e) {
11222       {
11223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11224       };
11225     } catch (std::exception& e) {
11226       {
11227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11228       };
11229     } catch (Dali::DaliException e) {
11230       {
11231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11232       };
11233     } catch (...) {
11234       {
11235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11236       };
11237     }
11238   }
11239
11240   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11241   return jresult;
11242 }
11243
11244
11245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11246   void * jresult ;
11247   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11248   Dali::Quaternion *arg2 = 0 ;
11249   Dali::Quaternion result;
11250
11251   arg1 = (Dali::Quaternion *)jarg1;
11252   arg2 = (Dali::Quaternion *)jarg2;
11253   if (!arg2) {
11254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11255     return 0;
11256   }
11257   {
11258     try {
11259       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11260     } catch (std::out_of_range& e) {
11261       {
11262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11263       };
11264     } catch (std::exception& e) {
11265       {
11266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11267       };
11268     } catch (Dali::DaliException e) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11271       };
11272     } catch (...) {
11273       {
11274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11275       };
11276     }
11277   }
11278
11279   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11280   return jresult;
11281 }
11282
11283
11284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11285   void * jresult ;
11286   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11287   float arg2 ;
11288   Dali::Quaternion result;
11289
11290   arg1 = (Dali::Quaternion *)jarg1;
11291   arg2 = (float)jarg2;
11292   {
11293     try {
11294       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11295     } catch (std::out_of_range& e) {
11296       {
11297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11298       };
11299     } catch (std::exception& e) {
11300       {
11301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11302       };
11303     } catch (Dali::DaliException e) {
11304       {
11305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11306       };
11307     } catch (...) {
11308       {
11309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11310       };
11311     }
11312   }
11313
11314   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11315   return jresult;
11316 }
11317
11318
11319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11320   void * jresult ;
11321   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11322   float arg2 ;
11323   Dali::Quaternion result;
11324
11325   arg1 = (Dali::Quaternion *)jarg1;
11326   arg2 = (float)jarg2;
11327   {
11328     try {
11329       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11330     } catch (std::out_of_range& e) {
11331       {
11332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11333       };
11334     } catch (std::exception& e) {
11335       {
11336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11337       };
11338     } catch (Dali::DaliException e) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11341       };
11342     } catch (...) {
11343       {
11344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11345       };
11346     }
11347   }
11348
11349   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11350   return jresult;
11351 }
11352
11353
11354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11355   void * jresult ;
11356   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11357   Dali::Quaternion result;
11358
11359   arg1 = (Dali::Quaternion *)jarg1;
11360   {
11361     try {
11362       result = ((Dali::Quaternion const *)arg1)->operator -();
11363     } catch (std::out_of_range& e) {
11364       {
11365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11366       };
11367     } catch (std::exception& e) {
11368       {
11369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11370       };
11371     } catch (Dali::DaliException e) {
11372       {
11373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11374       };
11375     } catch (...) {
11376       {
11377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11378       };
11379     }
11380   }
11381
11382   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11383   return jresult;
11384 }
11385
11386
11387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11388   void * jresult ;
11389   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11390   Dali::Quaternion *arg2 = 0 ;
11391   Dali::Quaternion *result = 0 ;
11392
11393   arg1 = (Dali::Quaternion *)jarg1;
11394   arg2 = (Dali::Quaternion *)jarg2;
11395   if (!arg2) {
11396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11397     return 0;
11398   }
11399   {
11400     try {
11401       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11402     } catch (std::out_of_range& e) {
11403       {
11404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11405       };
11406     } catch (std::exception& e) {
11407       {
11408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11409       };
11410     } catch (Dali::DaliException e) {
11411       {
11412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11413       };
11414     } catch (...) {
11415       {
11416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11417       };
11418     }
11419   }
11420
11421   jresult = (void *)result;
11422   return jresult;
11423 }
11424
11425
11426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11427   void * jresult ;
11428   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11429   Dali::Quaternion *arg2 = 0 ;
11430   Dali::Quaternion *result = 0 ;
11431
11432   arg1 = (Dali::Quaternion *)jarg1;
11433   arg2 = (Dali::Quaternion *)jarg2;
11434   if (!arg2) {
11435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11436     return 0;
11437   }
11438   {
11439     try {
11440       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11441     } catch (std::out_of_range& e) {
11442       {
11443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11444       };
11445     } catch (std::exception& e) {
11446       {
11447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11448       };
11449     } catch (Dali::DaliException e) {
11450       {
11451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11452       };
11453     } catch (...) {
11454       {
11455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11456       };
11457     }
11458   }
11459
11460   jresult = (void *)result;
11461   return jresult;
11462 }
11463
11464
11465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11466   void * jresult ;
11467   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11468   Dali::Quaternion *arg2 = 0 ;
11469   Dali::Quaternion *result = 0 ;
11470
11471   arg1 = (Dali::Quaternion *)jarg1;
11472   arg2 = (Dali::Quaternion *)jarg2;
11473   if (!arg2) {
11474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11475     return 0;
11476   }
11477   {
11478     try {
11479       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11480     } catch (std::out_of_range& e) {
11481       {
11482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11483       };
11484     } catch (std::exception& e) {
11485       {
11486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11487       };
11488     } catch (Dali::DaliException e) {
11489       {
11490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11491       };
11492     } catch (...) {
11493       {
11494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11495       };
11496     }
11497   }
11498
11499   jresult = (void *)result;
11500   return jresult;
11501 }
11502
11503
11504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11505   void * jresult ;
11506   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11507   float arg2 ;
11508   Dali::Quaternion *result = 0 ;
11509
11510   arg1 = (Dali::Quaternion *)jarg1;
11511   arg2 = (float)jarg2;
11512   {
11513     try {
11514       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11515     } catch (std::out_of_range& e) {
11516       {
11517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11518       };
11519     } catch (std::exception& e) {
11520       {
11521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11522       };
11523     } catch (Dali::DaliException e) {
11524       {
11525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11526       };
11527     } catch (...) {
11528       {
11529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11530       };
11531     }
11532   }
11533
11534   jresult = (void *)result;
11535   return jresult;
11536 }
11537
11538
11539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11540   void * jresult ;
11541   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11542   float arg2 ;
11543   Dali::Quaternion *result = 0 ;
11544
11545   arg1 = (Dali::Quaternion *)jarg1;
11546   arg2 = (float)jarg2;
11547   {
11548     try {
11549       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11550     } catch (std::out_of_range& e) {
11551       {
11552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11553       };
11554     } catch (std::exception& e) {
11555       {
11556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11557       };
11558     } catch (Dali::DaliException e) {
11559       {
11560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11561       };
11562     } catch (...) {
11563       {
11564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11565       };
11566     }
11567   }
11568
11569   jresult = (void *)result;
11570   return jresult;
11571 }
11572
11573
11574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11575   unsigned int jresult ;
11576   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11577   Dali::Quaternion *arg2 = 0 ;
11578   bool result;
11579
11580   arg1 = (Dali::Quaternion *)jarg1;
11581   arg2 = (Dali::Quaternion *)jarg2;
11582   if (!arg2) {
11583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11584     return 0;
11585   }
11586   {
11587     try {
11588       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11589     } catch (std::out_of_range& e) {
11590       {
11591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11592       };
11593     } catch (std::exception& e) {
11594       {
11595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11596       };
11597     } catch (Dali::DaliException e) {
11598       {
11599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11600       };
11601     } catch (...) {
11602       {
11603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11604       };
11605     }
11606   }
11607
11608   jresult = result;
11609   return jresult;
11610 }
11611
11612
11613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11614   unsigned int jresult ;
11615   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11616   Dali::Quaternion *arg2 = 0 ;
11617   bool result;
11618
11619   arg1 = (Dali::Quaternion *)jarg1;
11620   arg2 = (Dali::Quaternion *)jarg2;
11621   if (!arg2) {
11622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11623     return 0;
11624   }
11625   {
11626     try {
11627       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11628     } catch (std::out_of_range& e) {
11629       {
11630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11631       };
11632     } catch (std::exception& e) {
11633       {
11634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11635       };
11636     } catch (Dali::DaliException e) {
11637       {
11638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11639       };
11640     } catch (...) {
11641       {
11642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11643       };
11644     }
11645   }
11646
11647   jresult = result;
11648   return jresult;
11649 }
11650
11651
11652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11653   float jresult ;
11654   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11655   float result;
11656
11657   arg1 = (Dali::Quaternion *)jarg1;
11658   {
11659     try {
11660       result = (float)((Dali::Quaternion const *)arg1)->Length();
11661     } catch (std::out_of_range& e) {
11662       {
11663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11664       };
11665     } catch (std::exception& e) {
11666       {
11667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11668       };
11669     } catch (Dali::DaliException e) {
11670       {
11671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11672       };
11673     } catch (...) {
11674       {
11675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11676       };
11677     }
11678   }
11679
11680   jresult = result;
11681   return jresult;
11682 }
11683
11684
11685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11686   float jresult ;
11687   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11688   float result;
11689
11690   arg1 = (Dali::Quaternion *)jarg1;
11691   {
11692     try {
11693       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11694     } catch (std::out_of_range& e) {
11695       {
11696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11697       };
11698     } catch (std::exception& e) {
11699       {
11700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11701       };
11702     } catch (Dali::DaliException e) {
11703       {
11704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11705       };
11706     } catch (...) {
11707       {
11708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11709       };
11710     }
11711   }
11712
11713   jresult = result;
11714   return jresult;
11715 }
11716
11717
11718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11719   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11720
11721   arg1 = (Dali::Quaternion *)jarg1;
11722   {
11723     try {
11724       (arg1)->Normalize();
11725     } catch (std::out_of_range& e) {
11726       {
11727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11728       };
11729     } catch (std::exception& e) {
11730       {
11731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11732       };
11733     } catch (Dali::DaliException e) {
11734       {
11735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11736       };
11737     } catch (...) {
11738       {
11739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11740       };
11741     }
11742   }
11743
11744 }
11745
11746
11747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11748   void * jresult ;
11749   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11750   Dali::Quaternion result;
11751
11752   arg1 = (Dali::Quaternion *)jarg1;
11753   {
11754     try {
11755       result = ((Dali::Quaternion const *)arg1)->Normalized();
11756     } catch (std::out_of_range& e) {
11757       {
11758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11759       };
11760     } catch (std::exception& e) {
11761       {
11762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11763       };
11764     } catch (Dali::DaliException e) {
11765       {
11766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11767       };
11768     } catch (...) {
11769       {
11770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11771       };
11772     }
11773   }
11774
11775   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11776   return jresult;
11777 }
11778
11779
11780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11781   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11782
11783   arg1 = (Dali::Quaternion *)jarg1;
11784   {
11785     try {
11786       (arg1)->Conjugate();
11787     } catch (std::out_of_range& e) {
11788       {
11789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11790       };
11791     } catch (std::exception& e) {
11792       {
11793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11794       };
11795     } catch (Dali::DaliException e) {
11796       {
11797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11798       };
11799     } catch (...) {
11800       {
11801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11802       };
11803     }
11804   }
11805
11806 }
11807
11808
11809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11810   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11811
11812   arg1 = (Dali::Quaternion *)jarg1;
11813   {
11814     try {
11815       (arg1)->Invert();
11816     } catch (std::out_of_range& e) {
11817       {
11818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11819       };
11820     } catch (std::exception& e) {
11821       {
11822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11823       };
11824     } catch (Dali::DaliException e) {
11825       {
11826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11827       };
11828     } catch (...) {
11829       {
11830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11831       };
11832     }
11833   }
11834
11835 }
11836
11837
11838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11839   void * jresult ;
11840   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11841   Dali::Quaternion result;
11842
11843   arg1 = (Dali::Quaternion *)jarg1;
11844   {
11845     try {
11846       result = ((Dali::Quaternion const *)arg1)->Log();
11847     } catch (std::out_of_range& e) {
11848       {
11849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11850       };
11851     } catch (std::exception& e) {
11852       {
11853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11854       };
11855     } catch (Dali::DaliException e) {
11856       {
11857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11858       };
11859     } catch (...) {
11860       {
11861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11862       };
11863     }
11864   }
11865
11866   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11867   return jresult;
11868 }
11869
11870
11871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11872   void * jresult ;
11873   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11874   Dali::Quaternion result;
11875
11876   arg1 = (Dali::Quaternion *)jarg1;
11877   {
11878     try {
11879       result = ((Dali::Quaternion const *)arg1)->Exp();
11880     } catch (std::out_of_range& e) {
11881       {
11882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11883       };
11884     } catch (std::exception& e) {
11885       {
11886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11887       };
11888     } catch (Dali::DaliException e) {
11889       {
11890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11891       };
11892     } catch (...) {
11893       {
11894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11895       };
11896     }
11897   }
11898
11899   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11900   return jresult;
11901 }
11902
11903
11904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11905   float jresult ;
11906   Dali::Quaternion *arg1 = 0 ;
11907   Dali::Quaternion *arg2 = 0 ;
11908   float result;
11909
11910   arg1 = (Dali::Quaternion *)jarg1;
11911   if (!arg1) {
11912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11913     return 0;
11914   }
11915   arg2 = (Dali::Quaternion *)jarg2;
11916   if (!arg2) {
11917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11918     return 0;
11919   }
11920   {
11921     try {
11922       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11923     } catch (std::out_of_range& e) {
11924       {
11925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11926       };
11927     } catch (std::exception& e) {
11928       {
11929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11930       };
11931     } catch (Dali::DaliException e) {
11932       {
11933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11934       };
11935     } catch (...) {
11936       {
11937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11938       };
11939     }
11940   }
11941
11942   jresult = result;
11943   return jresult;
11944 }
11945
11946
11947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11948   void * jresult ;
11949   Dali::Quaternion *arg1 = 0 ;
11950   Dali::Quaternion *arg2 = 0 ;
11951   float arg3 ;
11952   Dali::Quaternion result;
11953
11954   arg1 = (Dali::Quaternion *)jarg1;
11955   if (!arg1) {
11956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11957     return 0;
11958   }
11959   arg2 = (Dali::Quaternion *)jarg2;
11960   if (!arg2) {
11961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11962     return 0;
11963   }
11964   arg3 = (float)jarg3;
11965   {
11966     try {
11967       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11968     } catch (std::out_of_range& e) {
11969       {
11970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11971       };
11972     } catch (std::exception& e) {
11973       {
11974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11975       };
11976     } catch (Dali::DaliException e) {
11977       {
11978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11979       };
11980     } catch (...) {
11981       {
11982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11983       };
11984     }
11985   }
11986
11987   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11988   return jresult;
11989 }
11990
11991
11992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11993   void * jresult ;
11994   Dali::Quaternion *arg1 = 0 ;
11995   Dali::Quaternion *arg2 = 0 ;
11996   float arg3 ;
11997   Dali::Quaternion result;
11998
11999   arg1 = (Dali::Quaternion *)jarg1;
12000   if (!arg1) {
12001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12002     return 0;
12003   }
12004   arg2 = (Dali::Quaternion *)jarg2;
12005   if (!arg2) {
12006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12007     return 0;
12008   }
12009   arg3 = (float)jarg3;
12010   {
12011     try {
12012       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12013     } catch (std::out_of_range& e) {
12014       {
12015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (std::exception& e) {
12018       {
12019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12020       };
12021     } catch (Dali::DaliException e) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12024       };
12025     } catch (...) {
12026       {
12027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12028       };
12029     }
12030   }
12031
12032   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12033   return jresult;
12034 }
12035
12036
12037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12038   void * jresult ;
12039   Dali::Quaternion *arg1 = 0 ;
12040   Dali::Quaternion *arg2 = 0 ;
12041   float arg3 ;
12042   Dali::Quaternion result;
12043
12044   arg1 = (Dali::Quaternion *)jarg1;
12045   if (!arg1) {
12046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12047     return 0;
12048   }
12049   arg2 = (Dali::Quaternion *)jarg2;
12050   if (!arg2) {
12051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12052     return 0;
12053   }
12054   arg3 = (float)jarg3;
12055   {
12056     try {
12057       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12058     } catch (std::out_of_range& e) {
12059       {
12060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12061       };
12062     } catch (std::exception& e) {
12063       {
12064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12065       };
12066     } catch (Dali::DaliException e) {
12067       {
12068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12069       };
12070     } catch (...) {
12071       {
12072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12073       };
12074     }
12075   }
12076
12077   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12078   return jresult;
12079 }
12080
12081
12082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12083   void * jresult ;
12084   Dali::Quaternion *arg1 = 0 ;
12085   Dali::Quaternion *arg2 = 0 ;
12086   Dali::Quaternion *arg3 = 0 ;
12087   Dali::Quaternion *arg4 = 0 ;
12088   float arg5 ;
12089   Dali::Quaternion result;
12090
12091   arg1 = (Dali::Quaternion *)jarg1;
12092   if (!arg1) {
12093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12094     return 0;
12095   }
12096   arg2 = (Dali::Quaternion *)jarg2;
12097   if (!arg2) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg3 = (Dali::Quaternion *)jarg3;
12102   if (!arg3) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   arg4 = (Dali::Quaternion *)jarg4;
12107   if (!arg4) {
12108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12109     return 0;
12110   }
12111   arg5 = (float)jarg5;
12112   {
12113     try {
12114       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12115     } catch (std::out_of_range& e) {
12116       {
12117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (std::exception& e) {
12120       {
12121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12122       };
12123     } catch (Dali::DaliException e) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12126       };
12127     } catch (...) {
12128       {
12129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12130       };
12131     }
12132   }
12133
12134   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12135   return jresult;
12136 }
12137
12138
12139 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12140   float jresult ;
12141   Dali::Quaternion *arg1 = 0 ;
12142   Dali::Quaternion *arg2 = 0 ;
12143   float result;
12144
12145   arg1 = (Dali::Quaternion *)jarg1;
12146   if (!arg1) {
12147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12148     return 0;
12149   }
12150   arg2 = (Dali::Quaternion *)jarg2;
12151   if (!arg2) {
12152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12153     return 0;
12154   }
12155   {
12156     try {
12157       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12158     } catch (std::out_of_range& e) {
12159       {
12160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12161       };
12162     } catch (std::exception& e) {
12163       {
12164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12165       };
12166     } catch (Dali::DaliException e) {
12167       {
12168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12169       };
12170     } catch (...) {
12171       {
12172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12173       };
12174     }
12175   }
12176
12177   jresult = result;
12178   return jresult;
12179 }
12180
12181
12182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12183   void * jresult ;
12184   Dali::Matrix *result = 0 ;
12185
12186   {
12187     try {
12188       result = (Dali::Matrix *)new Dali::Matrix();
12189     } catch (std::out_of_range& e) {
12190       {
12191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12192       };
12193     } catch (std::exception& e) {
12194       {
12195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12196       };
12197     } catch (Dali::DaliException e) {
12198       {
12199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12200       };
12201     } catch (...) {
12202       {
12203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12204       };
12205     }
12206   }
12207
12208   jresult = (void *)result;
12209   return jresult;
12210 }
12211
12212
12213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12214   void * jresult ;
12215   bool arg1 ;
12216   Dali::Matrix *result = 0 ;
12217
12218   arg1 = jarg1 ? true : false;
12219   {
12220     try {
12221       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12222     } catch (std::out_of_range& e) {
12223       {
12224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12225       };
12226     } catch (std::exception& e) {
12227       {
12228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12229       };
12230     } catch (Dali::DaliException e) {
12231       {
12232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12233       };
12234     } catch (...) {
12235       {
12236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12237       };
12238     }
12239   }
12240
12241   jresult = (void *)result;
12242   return jresult;
12243 }
12244
12245
12246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12247   void * jresult ;
12248   float *arg1 = (float *) 0 ;
12249   Dali::Matrix *result = 0 ;
12250
12251   arg1 = jarg1;
12252   {
12253     try {
12254       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12255     } catch (std::out_of_range& e) {
12256       {
12257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12258       };
12259     } catch (std::exception& e) {
12260       {
12261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12262       };
12263     } catch (Dali::DaliException e) {
12264       {
12265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12266       };
12267     } catch (...) {
12268       {
12269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12270       };
12271     }
12272   }
12273
12274   jresult = (void *)result;
12275
12276
12277   return jresult;
12278 }
12279
12280
12281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12282   void * jresult ;
12283   Dali::Quaternion *arg1 = 0 ;
12284   Dali::Matrix *result = 0 ;
12285
12286   arg1 = (Dali::Quaternion *)jarg1;
12287   if (!arg1) {
12288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12289     return 0;
12290   }
12291   {
12292     try {
12293       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12294     } catch (std::out_of_range& e) {
12295       {
12296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12297       };
12298     } catch (std::exception& e) {
12299       {
12300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12301       };
12302     } catch (Dali::DaliException e) {
12303       {
12304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12305       };
12306     } catch (...) {
12307       {
12308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12309       };
12310     }
12311   }
12312
12313   jresult = (void *)result;
12314   return jresult;
12315 }
12316
12317
12318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12319   void * jresult ;
12320   Dali::Matrix *arg1 = 0 ;
12321   Dali::Matrix *result = 0 ;
12322
12323   arg1 = (Dali::Matrix *)jarg1;
12324   if (!arg1) {
12325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12326     return 0;
12327   }
12328   {
12329     try {
12330       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12331     } catch (std::out_of_range& e) {
12332       {
12333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12334       };
12335     } catch (std::exception& e) {
12336       {
12337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12338       };
12339     } catch (Dali::DaliException e) {
12340       {
12341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12342       };
12343     } catch (...) {
12344       {
12345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12346       };
12347     }
12348   }
12349
12350   jresult = (void *)result;
12351   return jresult;
12352 }
12353
12354
12355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12356   void * jresult ;
12357   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12358   Dali::Matrix *arg2 = 0 ;
12359   Dali::Matrix *result = 0 ;
12360
12361   arg1 = (Dali::Matrix *)jarg1;
12362   arg2 = (Dali::Matrix *)jarg2;
12363   if (!arg2) {
12364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12365     return 0;
12366   }
12367   {
12368     try {
12369       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12370     } catch (std::out_of_range& e) {
12371       {
12372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12373       };
12374     } catch (std::exception& e) {
12375       {
12376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12377       };
12378     } catch (Dali::DaliException e) {
12379       {
12380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12381       };
12382     } catch (...) {
12383       {
12384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12385       };
12386     }
12387   }
12388
12389   jresult = (void *)result;
12390   return jresult;
12391 }
12392
12393
12394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12395   void * jresult ;
12396   Dali::Matrix *result = 0 ;
12397
12398   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12399   jresult = (void *)result;
12400   return jresult;
12401 }
12402
12403
12404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12405   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12406
12407   arg1 = (Dali::Matrix *)jarg1;
12408   {
12409     try {
12410       (arg1)->SetIdentity();
12411     } catch (std::out_of_range& e) {
12412       {
12413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12414       };
12415     } catch (std::exception& e) {
12416       {
12417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12418       };
12419     } catch (Dali::DaliException e) {
12420       {
12421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12422       };
12423     } catch (...) {
12424       {
12425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12426       };
12427     }
12428   }
12429
12430 }
12431
12432
12433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12434   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12435   Dali::Vector3 *arg2 = 0 ;
12436
12437   arg1 = (Dali::Matrix *)jarg1;
12438   arg2 = (Dali::Vector3 *)jarg2;
12439   if (!arg2) {
12440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12441     return ;
12442   }
12443   {
12444     try {
12445       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12446     } catch (std::out_of_range& e) {
12447       {
12448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12449       };
12450     } catch (std::exception& e) {
12451       {
12452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12453       };
12454     } catch (Dali::DaliException e) {
12455       {
12456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12457       };
12458     } catch (...) {
12459       {
12460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12461       };
12462     }
12463   }
12464
12465 }
12466
12467
12468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12469   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12470   Dali::Matrix *arg2 = 0 ;
12471
12472   arg1 = (Dali::Matrix *)jarg1;
12473   arg2 = (Dali::Matrix *)jarg2;
12474   if (!arg2) {
12475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12476     return ;
12477   }
12478   {
12479     try {
12480       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12481     } catch (std::out_of_range& e) {
12482       {
12483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12484       };
12485     } catch (std::exception& e) {
12486       {
12487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12488       };
12489     } catch (Dali::DaliException e) {
12490       {
12491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12492       };
12493     } catch (...) {
12494       {
12495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12496       };
12497     }
12498   }
12499
12500 }
12501
12502
12503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12504   unsigned int jresult ;
12505   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12506   bool result;
12507
12508   arg1 = (Dali::Matrix *)jarg1;
12509   {
12510     try {
12511       result = (bool)(arg1)->Invert();
12512     } catch (std::out_of_range& e) {
12513       {
12514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12515       };
12516     } catch (std::exception& e) {
12517       {
12518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12519       };
12520     } catch (Dali::DaliException e) {
12521       {
12522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12523       };
12524     } catch (...) {
12525       {
12526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12527       };
12528     }
12529   }
12530
12531   jresult = result;
12532   return jresult;
12533 }
12534
12535
12536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12537   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12538
12539   arg1 = (Dali::Matrix *)jarg1;
12540   {
12541     try {
12542       (arg1)->Transpose();
12543     } catch (std::out_of_range& e) {
12544       {
12545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12546       };
12547     } catch (std::exception& e) {
12548       {
12549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12550       };
12551     } catch (Dali::DaliException e) {
12552       {
12553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12554       };
12555     } catch (...) {
12556       {
12557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12558       };
12559     }
12560   }
12561
12562 }
12563
12564
12565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12566   void * jresult ;
12567   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12568   Dali::Vector3 result;
12569
12570   arg1 = (Dali::Matrix *)jarg1;
12571   {
12572     try {
12573       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12574     } catch (std::out_of_range& e) {
12575       {
12576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12577       };
12578     } catch (std::exception& e) {
12579       {
12580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12581       };
12582     } catch (Dali::DaliException e) {
12583       {
12584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12585       };
12586     } catch (...) {
12587       {
12588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12589       };
12590     }
12591   }
12592
12593   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12594   return jresult;
12595 }
12596
12597
12598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12599   void * jresult ;
12600   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12601   Dali::Vector3 result;
12602
12603   arg1 = (Dali::Matrix *)jarg1;
12604   {
12605     try {
12606       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12607     } catch (std::out_of_range& e) {
12608       {
12609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12610       };
12611     } catch (std::exception& e) {
12612       {
12613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12614       };
12615     } catch (Dali::DaliException e) {
12616       {
12617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12618       };
12619     } catch (...) {
12620       {
12621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12622       };
12623     }
12624   }
12625
12626   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12627   return jresult;
12628 }
12629
12630
12631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12632   void * jresult ;
12633   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12634   Dali::Vector3 result;
12635
12636   arg1 = (Dali::Matrix *)jarg1;
12637   {
12638     try {
12639       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12640     } catch (std::out_of_range& e) {
12641       {
12642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12643       };
12644     } catch (std::exception& e) {
12645       {
12646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12647       };
12648     } catch (Dali::DaliException e) {
12649       {
12650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12651       };
12652     } catch (...) {
12653       {
12654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12655       };
12656     }
12657   }
12658
12659   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12660   return jresult;
12661 }
12662
12663
12664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12665   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12666   Dali::Vector3 *arg2 = 0 ;
12667
12668   arg1 = (Dali::Matrix *)jarg1;
12669   arg2 = (Dali::Vector3 *)jarg2;
12670   if (!arg2) {
12671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12672     return ;
12673   }
12674   {
12675     try {
12676       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12677     } catch (std::out_of_range& e) {
12678       {
12679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12680       };
12681     } catch (std::exception& e) {
12682       {
12683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12684       };
12685     } catch (Dali::DaliException e) {
12686       {
12687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12688       };
12689     } catch (...) {
12690       {
12691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12692       };
12693     }
12694   }
12695
12696 }
12697
12698
12699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12700   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12701   Dali::Vector3 *arg2 = 0 ;
12702
12703   arg1 = (Dali::Matrix *)jarg1;
12704   arg2 = (Dali::Vector3 *)jarg2;
12705   if (!arg2) {
12706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12707     return ;
12708   }
12709   {
12710     try {
12711       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12712     } catch (std::out_of_range& e) {
12713       {
12714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12715       };
12716     } catch (std::exception& e) {
12717       {
12718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12719       };
12720     } catch (Dali::DaliException e) {
12721       {
12722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12723       };
12724     } catch (...) {
12725       {
12726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12727       };
12728     }
12729   }
12730
12731 }
12732
12733
12734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12735   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12736   Dali::Vector3 *arg2 = 0 ;
12737
12738   arg1 = (Dali::Matrix *)jarg1;
12739   arg2 = (Dali::Vector3 *)jarg2;
12740   if (!arg2) {
12741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12742     return ;
12743   }
12744   {
12745     try {
12746       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12747     } catch (std::out_of_range& e) {
12748       {
12749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12750       };
12751     } catch (std::exception& e) {
12752       {
12753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12754       };
12755     } catch (Dali::DaliException e) {
12756       {
12757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12758       };
12759     } catch (...) {
12760       {
12761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12762       };
12763     }
12764   }
12765
12766 }
12767
12768
12769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12770   void * jresult ;
12771   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12772   Dali::Vector4 *result = 0 ;
12773
12774   arg1 = (Dali::Matrix *)jarg1;
12775   {
12776     try {
12777       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12778     } catch (std::out_of_range& e) {
12779       {
12780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (std::exception& e) {
12783       {
12784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12785       };
12786     } catch (Dali::DaliException e) {
12787       {
12788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12789       };
12790     } catch (...) {
12791       {
12792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12793       };
12794     }
12795   }
12796
12797   jresult = (void *)result;
12798   return jresult;
12799 }
12800
12801
12802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12803   void * jresult ;
12804   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12805   Dali::Vector3 *result = 0 ;
12806
12807   arg1 = (Dali::Matrix *)jarg1;
12808   {
12809     try {
12810       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12811     } catch (std::out_of_range& e) {
12812       {
12813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12814       };
12815     } catch (std::exception& e) {
12816       {
12817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12818       };
12819     } catch (Dali::DaliException e) {
12820       {
12821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12822       };
12823     } catch (...) {
12824       {
12825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12826       };
12827     }
12828   }
12829
12830   jresult = (void *)result;
12831   return jresult;
12832 }
12833
12834
12835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12836   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12837   Dali::Vector4 *arg2 = 0 ;
12838
12839   arg1 = (Dali::Matrix *)jarg1;
12840   arg2 = (Dali::Vector4 *)jarg2;
12841   if (!arg2) {
12842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12843     return ;
12844   }
12845   {
12846     try {
12847       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12848     } catch (std::out_of_range& e) {
12849       {
12850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12851       };
12852     } catch (std::exception& e) {
12853       {
12854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12855       };
12856     } catch (Dali::DaliException e) {
12857       {
12858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12859       };
12860     } catch (...) {
12861       {
12862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12863       };
12864     }
12865   }
12866
12867 }
12868
12869
12870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12871   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12872   Dali::Vector3 *arg2 = 0 ;
12873
12874   arg1 = (Dali::Matrix *)jarg1;
12875   arg2 = (Dali::Vector3 *)jarg2;
12876   if (!arg2) {
12877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12878     return ;
12879   }
12880   {
12881     try {
12882       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12883     } catch (std::out_of_range& e) {
12884       {
12885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12886       };
12887     } catch (std::exception& e) {
12888       {
12889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12890       };
12891     } catch (Dali::DaliException e) {
12892       {
12893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12894       };
12895     } catch (...) {
12896       {
12897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12898       };
12899     }
12900   }
12901
12902 }
12903
12904
12905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12906   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12907
12908   arg1 = (Dali::Matrix *)jarg1;
12909   {
12910     try {
12911       (arg1)->OrthoNormalize();
12912     } catch (std::out_of_range& e) {
12913       {
12914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12915       };
12916     } catch (std::exception& e) {
12917       {
12918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12919       };
12920     } catch (Dali::DaliException e) {
12921       {
12922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12923       };
12924     } catch (...) {
12925       {
12926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12927       };
12928     }
12929   }
12930
12931 }
12932
12933
12934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12935   void * jresult ;
12936   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12937   float *result = 0 ;
12938
12939   arg1 = (Dali::Matrix *)jarg1;
12940   {
12941     try {
12942       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12943     } catch (std::out_of_range& e) {
12944       {
12945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12946       };
12947     } catch (std::exception& e) {
12948       {
12949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12950       };
12951     } catch (Dali::DaliException e) {
12952       {
12953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12954       };
12955     } catch (...) {
12956       {
12957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12958       };
12959     }
12960   }
12961
12962   jresult = (void *)result;
12963   return jresult;
12964 }
12965
12966
12967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12968   Dali::Matrix *arg1 = 0 ;
12969   Dali::Matrix *arg2 = 0 ;
12970   Dali::Matrix *arg3 = 0 ;
12971
12972   arg1 = (Dali::Matrix *)jarg1;
12973   if (!arg1) {
12974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12975     return ;
12976   }
12977   arg2 = (Dali::Matrix *)jarg2;
12978   if (!arg2) {
12979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12980     return ;
12981   }
12982   arg3 = (Dali::Matrix *)jarg3;
12983   if (!arg3) {
12984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12985     return ;
12986   }
12987   {
12988     try {
12989       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12990     } catch (std::out_of_range& e) {
12991       {
12992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12993       };
12994     } catch (std::exception& e) {
12995       {
12996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12997       };
12998     } catch (Dali::DaliException e) {
12999       {
13000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13001       };
13002     } catch (...) {
13003       {
13004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13005       };
13006     }
13007   }
13008
13009 }
13010
13011
13012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13013   Dali::Matrix *arg1 = 0 ;
13014   Dali::Matrix *arg2 = 0 ;
13015   Dali::Quaternion *arg3 = 0 ;
13016
13017   arg1 = (Dali::Matrix *)jarg1;
13018   if (!arg1) {
13019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13020     return ;
13021   }
13022   arg2 = (Dali::Matrix *)jarg2;
13023   if (!arg2) {
13024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13025     return ;
13026   }
13027   arg3 = (Dali::Quaternion *)jarg3;
13028   if (!arg3) {
13029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13030     return ;
13031   }
13032   {
13033     try {
13034       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13035     } catch (std::out_of_range& e) {
13036       {
13037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13038       };
13039     } catch (std::exception& e) {
13040       {
13041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13042       };
13043     } catch (Dali::DaliException e) {
13044       {
13045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13046       };
13047     } catch (...) {
13048       {
13049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13050       };
13051     }
13052   }
13053
13054 }
13055
13056
13057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13058   void * jresult ;
13059   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13060   Dali::Vector4 *arg2 = 0 ;
13061   Dali::Vector4 result;
13062
13063   arg1 = (Dali::Matrix *)jarg1;
13064   arg2 = (Dali::Vector4 *)jarg2;
13065   if (!arg2) {
13066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13067     return 0;
13068   }
13069   {
13070     try {
13071       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13072     } catch (std::out_of_range& e) {
13073       {
13074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13075       };
13076     } catch (std::exception& e) {
13077       {
13078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13079       };
13080     } catch (Dali::DaliException e) {
13081       {
13082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13083       };
13084     } catch (...) {
13085       {
13086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13087       };
13088     }
13089   }
13090
13091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13092   return jresult;
13093 }
13094
13095
13096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13097   unsigned int jresult ;
13098   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13099   Dali::Matrix *arg2 = 0 ;
13100   bool result;
13101
13102   arg1 = (Dali::Matrix *)jarg1;
13103   arg2 = (Dali::Matrix *)jarg2;
13104   if (!arg2) {
13105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13106     return 0;
13107   }
13108   {
13109     try {
13110       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13111     } catch (std::out_of_range& e) {
13112       {
13113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13114       };
13115     } catch (std::exception& e) {
13116       {
13117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13118       };
13119     } catch (Dali::DaliException e) {
13120       {
13121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13122       };
13123     } catch (...) {
13124       {
13125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13126       };
13127     }
13128   }
13129
13130   jresult = result;
13131   return jresult;
13132 }
13133
13134
13135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13136   unsigned int jresult ;
13137   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13138   Dali::Matrix *arg2 = 0 ;
13139   bool result;
13140
13141   arg1 = (Dali::Matrix *)jarg1;
13142   arg2 = (Dali::Matrix *)jarg2;
13143   if (!arg2) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13145     return 0;
13146   }
13147   {
13148     try {
13149       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13150     } catch (std::out_of_range& e) {
13151       {
13152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13153       };
13154     } catch (std::exception& e) {
13155       {
13156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13157       };
13158     } catch (Dali::DaliException e) {
13159       {
13160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13161       };
13162     } catch (...) {
13163       {
13164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13165       };
13166     }
13167   }
13168
13169   jresult = result;
13170   return jresult;
13171 }
13172
13173
13174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13175   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13176   Dali::Vector3 *arg2 = 0 ;
13177   Dali::Quaternion *arg3 = 0 ;
13178   Dali::Vector3 *arg4 = 0 ;
13179
13180   arg1 = (Dali::Matrix *)jarg1;
13181   arg2 = (Dali::Vector3 *)jarg2;
13182   if (!arg2) {
13183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13184     return ;
13185   }
13186   arg3 = (Dali::Quaternion *)jarg3;
13187   if (!arg3) {
13188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13189     return ;
13190   }
13191   arg4 = (Dali::Vector3 *)jarg4;
13192   if (!arg4) {
13193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13194     return ;
13195   }
13196   {
13197     try {
13198       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13199     } catch (std::out_of_range& e) {
13200       {
13201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13202       };
13203     } catch (std::exception& e) {
13204       {
13205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13206       };
13207     } catch (Dali::DaliException e) {
13208       {
13209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13210       };
13211     } catch (...) {
13212       {
13213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13214       };
13215     }
13216   }
13217
13218 }
13219
13220
13221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13222   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13223   Dali::Vector3 *arg2 = 0 ;
13224   Dali::Quaternion *arg3 = 0 ;
13225   Dali::Vector3 *arg4 = 0 ;
13226
13227   arg1 = (Dali::Matrix *)jarg1;
13228   arg2 = (Dali::Vector3 *)jarg2;
13229   if (!arg2) {
13230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13231     return ;
13232   }
13233   arg3 = (Dali::Quaternion *)jarg3;
13234   if (!arg3) {
13235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13236     return ;
13237   }
13238   arg4 = (Dali::Vector3 *)jarg4;
13239   if (!arg4) {
13240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13241     return ;
13242   }
13243   {
13244     try {
13245       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13246     } catch (std::out_of_range& e) {
13247       {
13248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13249       };
13250     } catch (std::exception& e) {
13251       {
13252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13253       };
13254     } catch (Dali::DaliException e) {
13255       {
13256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13257       };
13258     } catch (...) {
13259       {
13260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13261       };
13262     }
13263   }
13264
13265 }
13266
13267
13268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13269   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13270   Dali::Vector3 *arg2 = 0 ;
13271   Dali::Vector3 *arg3 = 0 ;
13272   Dali::Vector3 *arg4 = 0 ;
13273   Dali::Vector3 *arg5 = 0 ;
13274
13275   arg1 = (Dali::Matrix *)jarg1;
13276   arg2 = (Dali::Vector3 *)jarg2;
13277   if (!arg2) {
13278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13279     return ;
13280   }
13281   arg3 = (Dali::Vector3 *)jarg3;
13282   if (!arg3) {
13283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13284     return ;
13285   }
13286   arg4 = (Dali::Vector3 *)jarg4;
13287   if (!arg4) {
13288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13289     return ;
13290   }
13291   arg5 = (Dali::Vector3 *)jarg5;
13292   if (!arg5) {
13293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13294     return ;
13295   }
13296   {
13297     try {
13298       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13299     } catch (std::out_of_range& e) {
13300       {
13301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13302       };
13303     } catch (std::exception& e) {
13304       {
13305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13306       };
13307     } catch (Dali::DaliException e) {
13308       {
13309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13310       };
13311     } catch (...) {
13312       {
13313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13314       };
13315     }
13316   }
13317
13318 }
13319
13320
13321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13322   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13323   Dali::Vector3 *arg2 = 0 ;
13324   Dali::Quaternion *arg3 = 0 ;
13325   Dali::Vector3 *arg4 = 0 ;
13326
13327   arg1 = (Dali::Matrix *)jarg1;
13328   arg2 = (Dali::Vector3 *)jarg2;
13329   if (!arg2) {
13330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13331     return ;
13332   }
13333   arg3 = (Dali::Quaternion *)jarg3;
13334   if (!arg3) {
13335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13336     return ;
13337   }
13338   arg4 = (Dali::Vector3 *)jarg4;
13339   if (!arg4) {
13340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13341     return ;
13342   }
13343   {
13344     try {
13345       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13346     } catch (std::out_of_range& e) {
13347       {
13348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (std::exception& e) {
13351       {
13352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13353       };
13354     } catch (Dali::DaliException e) {
13355       {
13356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13357       };
13358     } catch (...) {
13359       {
13360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13361       };
13362     }
13363   }
13364
13365 }
13366
13367
13368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13369   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13370
13371   arg1 = (Dali::Matrix *)jarg1;
13372   {
13373     try {
13374       delete arg1;
13375     } catch (std::out_of_range& e) {
13376       {
13377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13378       };
13379     } catch (std::exception& e) {
13380       {
13381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13382       };
13383     } catch (Dali::DaliException e) {
13384       {
13385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13386       };
13387     } catch (...) {
13388       {
13389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13390       };
13391     }
13392   }
13393
13394 }
13395
13396
13397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13398   void * jresult ;
13399   Dali::Matrix3 *result = 0 ;
13400
13401   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13402   jresult = (void *)result;
13403   return jresult;
13404 }
13405
13406
13407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13408   void * jresult ;
13409   Dali::Matrix3 *result = 0 ;
13410
13411   {
13412     try {
13413       result = (Dali::Matrix3 *)new Dali::Matrix3();
13414     } catch (std::out_of_range& e) {
13415       {
13416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13417       };
13418     } catch (std::exception& e) {
13419       {
13420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13421       };
13422     } catch (Dali::DaliException e) {
13423       {
13424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13425       };
13426     } catch (...) {
13427       {
13428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13429       };
13430     }
13431   }
13432
13433   jresult = (void *)result;
13434   return jresult;
13435 }
13436
13437
13438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13439   void * jresult ;
13440   Dali::Matrix3 *arg1 = 0 ;
13441   Dali::Matrix3 *result = 0 ;
13442
13443   arg1 = (Dali::Matrix3 *)jarg1;
13444   if (!arg1) {
13445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13446     return 0;
13447   }
13448   {
13449     try {
13450       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13451     } catch (std::out_of_range& e) {
13452       {
13453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13454       };
13455     } catch (std::exception& e) {
13456       {
13457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13458       };
13459     } catch (Dali::DaliException e) {
13460       {
13461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13462       };
13463     } catch (...) {
13464       {
13465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13466       };
13467     }
13468   }
13469
13470   jresult = (void *)result;
13471   return jresult;
13472 }
13473
13474
13475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13476   void * jresult ;
13477   Dali::Matrix *arg1 = 0 ;
13478   Dali::Matrix3 *result = 0 ;
13479
13480   arg1 = (Dali::Matrix *)jarg1;
13481   if (!arg1) {
13482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13483     return 0;
13484   }
13485   {
13486     try {
13487       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13488     } catch (std::out_of_range& e) {
13489       {
13490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13491       };
13492     } catch (std::exception& e) {
13493       {
13494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13495       };
13496     } catch (Dali::DaliException e) {
13497       {
13498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13499       };
13500     } catch (...) {
13501       {
13502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13503       };
13504     }
13505   }
13506
13507   jresult = (void *)result;
13508   return jresult;
13509 }
13510
13511
13512 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) {
13513   void * jresult ;
13514   float arg1 ;
13515   float arg2 ;
13516   float arg3 ;
13517   float arg4 ;
13518   float arg5 ;
13519   float arg6 ;
13520   float arg7 ;
13521   float arg8 ;
13522   float arg9 ;
13523   Dali::Matrix3 *result = 0 ;
13524
13525   arg1 = (float)jarg1;
13526   arg2 = (float)jarg2;
13527   arg3 = (float)jarg3;
13528   arg4 = (float)jarg4;
13529   arg5 = (float)jarg5;
13530   arg6 = (float)jarg6;
13531   arg7 = (float)jarg7;
13532   arg8 = (float)jarg8;
13533   arg9 = (float)jarg9;
13534   {
13535     try {
13536       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13537     } catch (std::out_of_range& e) {
13538       {
13539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13540       };
13541     } catch (std::exception& e) {
13542       {
13543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13544       };
13545     } catch (Dali::DaliException e) {
13546       {
13547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13548       };
13549     } catch (...) {
13550       {
13551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13552       };
13553     }
13554   }
13555
13556   jresult = (void *)result;
13557   return jresult;
13558 }
13559
13560
13561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13562   void * jresult ;
13563   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13564   Dali::Matrix3 *arg2 = 0 ;
13565   Dali::Matrix3 *result = 0 ;
13566
13567   arg1 = (Dali::Matrix3 *)jarg1;
13568   arg2 = (Dali::Matrix3 *)jarg2;
13569   if (!arg2) {
13570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13571     return 0;
13572   }
13573   {
13574     try {
13575       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13576     } catch (std::out_of_range& e) {
13577       {
13578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13579       };
13580     } catch (std::exception& e) {
13581       {
13582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13583       };
13584     } catch (Dali::DaliException e) {
13585       {
13586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13587       };
13588     } catch (...) {
13589       {
13590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13591       };
13592     }
13593   }
13594
13595   jresult = (void *)result;
13596   return jresult;
13597 }
13598
13599
13600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13601   void * jresult ;
13602   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13603   Dali::Matrix *arg2 = 0 ;
13604   Dali::Matrix3 *result = 0 ;
13605
13606   arg1 = (Dali::Matrix3 *)jarg1;
13607   arg2 = (Dali::Matrix *)jarg2;
13608   if (!arg2) {
13609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13610     return 0;
13611   }
13612   {
13613     try {
13614       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13615     } catch (std::out_of_range& e) {
13616       {
13617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13618       };
13619     } catch (std::exception& e) {
13620       {
13621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13622       };
13623     } catch (Dali::DaliException e) {
13624       {
13625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13626       };
13627     } catch (...) {
13628       {
13629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13630       };
13631     }
13632   }
13633
13634   jresult = (void *)result;
13635   return jresult;
13636 }
13637
13638
13639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13640   unsigned int jresult ;
13641   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13642   Dali::Matrix3 *arg2 = 0 ;
13643   bool result;
13644
13645   arg1 = (Dali::Matrix3 *)jarg1;
13646   arg2 = (Dali::Matrix3 *)jarg2;
13647   if (!arg2) {
13648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13649     return 0;
13650   }
13651   {
13652     try {
13653       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13654     } catch (std::out_of_range& e) {
13655       {
13656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13657       };
13658     } catch (std::exception& e) {
13659       {
13660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13661       };
13662     } catch (Dali::DaliException e) {
13663       {
13664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13665       };
13666     } catch (...) {
13667       {
13668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13669       };
13670     }
13671   }
13672
13673   jresult = result;
13674   return jresult;
13675 }
13676
13677
13678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13679   unsigned int jresult ;
13680   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13681   Dali::Matrix3 *arg2 = 0 ;
13682   bool result;
13683
13684   arg1 = (Dali::Matrix3 *)jarg1;
13685   arg2 = (Dali::Matrix3 *)jarg2;
13686   if (!arg2) {
13687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13688     return 0;
13689   }
13690   {
13691     try {
13692       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13693     } catch (std::out_of_range& e) {
13694       {
13695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13696       };
13697     } catch (std::exception& e) {
13698       {
13699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13700       };
13701     } catch (Dali::DaliException e) {
13702       {
13703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13704       };
13705     } catch (...) {
13706       {
13707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13708       };
13709     }
13710   }
13711
13712   jresult = result;
13713   return jresult;
13714 }
13715
13716
13717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13718   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13719
13720   arg1 = (Dali::Matrix3 *)jarg1;
13721   {
13722     try {
13723       delete arg1;
13724     } catch (std::out_of_range& e) {
13725       {
13726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13727       };
13728     } catch (std::exception& e) {
13729       {
13730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13731       };
13732     } catch (Dali::DaliException e) {
13733       {
13734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13735       };
13736     } catch (...) {
13737       {
13738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13739       };
13740     }
13741   }
13742
13743 }
13744
13745
13746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13747   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13748
13749   arg1 = (Dali::Matrix3 *)jarg1;
13750   {
13751     try {
13752       (arg1)->SetIdentity();
13753     } catch (std::out_of_range& e) {
13754       {
13755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13756       };
13757     } catch (std::exception& e) {
13758       {
13759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13760       };
13761     } catch (Dali::DaliException e) {
13762       {
13763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13764       };
13765     } catch (...) {
13766       {
13767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13768       };
13769     }
13770   }
13771
13772 }
13773
13774
13775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13776   void * jresult ;
13777   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13778   float *result = 0 ;
13779
13780   arg1 = (Dali::Matrix3 *)jarg1;
13781   {
13782     try {
13783       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13784     } catch (std::out_of_range& e) {
13785       {
13786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (std::exception& e) {
13789       {
13790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13791       };
13792     } catch (Dali::DaliException e) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13795       };
13796     } catch (...) {
13797       {
13798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13799       };
13800     }
13801   }
13802
13803   jresult = (void *)result;
13804   return jresult;
13805 }
13806
13807
13808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13809   unsigned int jresult ;
13810   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13811   bool result;
13812
13813   arg1 = (Dali::Matrix3 *)jarg1;
13814   {
13815     try {
13816       result = (bool)(arg1)->Invert();
13817     } catch (std::out_of_range& e) {
13818       {
13819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (std::exception& e) {
13822       {
13823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13824       };
13825     } catch (Dali::DaliException e) {
13826       {
13827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13828       };
13829     } catch (...) {
13830       {
13831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13832       };
13833     }
13834   }
13835
13836   jresult = result;
13837   return jresult;
13838 }
13839
13840
13841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13842   unsigned int jresult ;
13843   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13844   bool result;
13845
13846   arg1 = (Dali::Matrix3 *)jarg1;
13847   {
13848     try {
13849       result = (bool)(arg1)->Transpose();
13850     } catch (std::out_of_range& e) {
13851       {
13852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13853       };
13854     } catch (std::exception& e) {
13855       {
13856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13857       };
13858     } catch (Dali::DaliException e) {
13859       {
13860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13861       };
13862     } catch (...) {
13863       {
13864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13865       };
13866     }
13867   }
13868
13869   jresult = result;
13870   return jresult;
13871 }
13872
13873
13874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13875   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13876   float arg2 ;
13877
13878   arg1 = (Dali::Matrix3 *)jarg1;
13879   arg2 = (float)jarg2;
13880   {
13881     try {
13882       (arg1)->Scale(arg2);
13883     } catch (std::out_of_range& e) {
13884       {
13885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13886       };
13887     } catch (std::exception& e) {
13888       {
13889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13890       };
13891     } catch (Dali::DaliException e) {
13892       {
13893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13894       };
13895     } catch (...) {
13896       {
13897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13898       };
13899     }
13900   }
13901
13902 }
13903
13904
13905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13906   float jresult ;
13907   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13908   float result;
13909
13910   arg1 = (Dali::Matrix3 *)jarg1;
13911   {
13912     try {
13913       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13914     } catch (std::out_of_range& e) {
13915       {
13916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13917       };
13918     } catch (std::exception& e) {
13919       {
13920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13921       };
13922     } catch (Dali::DaliException e) {
13923       {
13924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13925       };
13926     } catch (...) {
13927       {
13928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13929       };
13930     }
13931   }
13932
13933   jresult = result;
13934   return jresult;
13935 }
13936
13937
13938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13939   unsigned int jresult ;
13940   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13941   bool result;
13942
13943   arg1 = (Dali::Matrix3 *)jarg1;
13944   {
13945     try {
13946       result = (bool)(arg1)->ScaledInverseTranspose();
13947     } catch (std::out_of_range& e) {
13948       {
13949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13950       };
13951     } catch (std::exception& e) {
13952       {
13953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13954       };
13955     } catch (Dali::DaliException e) {
13956       {
13957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13958       };
13959     } catch (...) {
13960       {
13961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13962       };
13963     }
13964   }
13965
13966   jresult = result;
13967   return jresult;
13968 }
13969
13970
13971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13972   Dali::Matrix3 *arg1 = 0 ;
13973   Dali::Matrix3 *arg2 = 0 ;
13974   Dali::Matrix3 *arg3 = 0 ;
13975
13976   arg1 = (Dali::Matrix3 *)jarg1;
13977   if (!arg1) {
13978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13979     return ;
13980   }
13981   arg2 = (Dali::Matrix3 *)jarg2;
13982   if (!arg2) {
13983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13984     return ;
13985   }
13986   arg3 = (Dali::Matrix3 *)jarg3;
13987   if (!arg3) {
13988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13989     return ;
13990   }
13991   {
13992     try {
13993       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13994     } catch (std::out_of_range& e) {
13995       {
13996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13997       };
13998     } catch (std::exception& e) {
13999       {
14000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14001       };
14002     } catch (Dali::DaliException e) {
14003       {
14004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14005       };
14006     } catch (...) {
14007       {
14008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14009       };
14010     }
14011   }
14012
14013 }
14014
14015
14016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14017   float jresult ;
14018   float arg1 ;
14019   float arg2 ;
14020   float result;
14021
14022   arg1 = (float)jarg1;
14023   arg2 = (float)jarg2;
14024   {
14025     try {
14026       result = (float)Dali::Random::Range(arg1,arg2);
14027     } catch (std::out_of_range& e) {
14028       {
14029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14030       };
14031     } catch (std::exception& e) {
14032       {
14033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14034       };
14035     } catch (Dali::DaliException e) {
14036       {
14037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14038       };
14039     } catch (...) {
14040       {
14041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14042       };
14043     }
14044   }
14045
14046   jresult = result;
14047   return jresult;
14048 }
14049
14050
14051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14052   void * jresult ;
14053   Dali::Vector4 result;
14054
14055   {
14056     try {
14057       result = Dali::Random::Axis();
14058     } catch (std::out_of_range& e) {
14059       {
14060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14061       };
14062     } catch (std::exception& e) {
14063       {
14064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14065       };
14066     } catch (Dali::DaliException e) {
14067       {
14068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14069       };
14070     } catch (...) {
14071       {
14072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14073       };
14074     }
14075   }
14076
14077   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14078   return jresult;
14079 }
14080
14081
14082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14083   void * jresult ;
14084   Dali::AngleAxis *result = 0 ;
14085
14086   {
14087     try {
14088       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14089     } catch (std::out_of_range& e) {
14090       {
14091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14092       };
14093     } catch (std::exception& e) {
14094       {
14095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14096       };
14097     } catch (Dali::DaliException e) {
14098       {
14099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14100       };
14101     } catch (...) {
14102       {
14103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14104       };
14105     }
14106   }
14107
14108   jresult = (void *)result;
14109   return jresult;
14110 }
14111
14112
14113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14114   void * jresult ;
14115   Dali::Radian arg1 ;
14116   Dali::Vector3 *arg2 = 0 ;
14117   Dali::Radian *argp1 ;
14118   Dali::AngleAxis *result = 0 ;
14119
14120   argp1 = (Dali::Radian *)jarg1;
14121   if (!argp1) {
14122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14123     return 0;
14124   }
14125   arg1 = *argp1;
14126   arg2 = (Dali::Vector3 *)jarg2;
14127   if (!arg2) {
14128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14129     return 0;
14130   }
14131   {
14132     try {
14133       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14134     } catch (std::out_of_range& e) {
14135       {
14136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14137       };
14138     } catch (std::exception& e) {
14139       {
14140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14141       };
14142     } catch (Dali::DaliException e) {
14143       {
14144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14145       };
14146     } catch (...) {
14147       {
14148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14149       };
14150     }
14151   }
14152
14153   jresult = (void *)result;
14154   return jresult;
14155 }
14156
14157
14158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14159   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14160   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14161
14162   arg1 = (Dali::AngleAxis *)jarg1;
14163   arg2 = (Dali::Radian *)jarg2;
14164   if (arg1) (arg1)->angle = *arg2;
14165 }
14166
14167
14168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14169   void * jresult ;
14170   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14171   Dali::Radian *result = 0 ;
14172
14173   arg1 = (Dali::AngleAxis *)jarg1;
14174   result = (Dali::Radian *)& ((arg1)->angle);
14175   jresult = (void *)result;
14176   return jresult;
14177 }
14178
14179
14180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14181   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14182   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14183
14184   arg1 = (Dali::AngleAxis *)jarg1;
14185   arg2 = (Dali::Vector3 *)jarg2;
14186   if (arg1) (arg1)->axis = *arg2;
14187 }
14188
14189
14190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14191   void * jresult ;
14192   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14193   Dali::Vector3 *result = 0 ;
14194
14195   arg1 = (Dali::AngleAxis *)jarg1;
14196   result = (Dali::Vector3 *)& ((arg1)->axis);
14197   jresult = (void *)result;
14198   return jresult;
14199 }
14200
14201
14202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14203   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14204
14205   arg1 = (Dali::AngleAxis *)jarg1;
14206   {
14207     try {
14208       delete arg1;
14209     } catch (std::out_of_range& e) {
14210       {
14211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14212       };
14213     } catch (std::exception& e) {
14214       {
14215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14216       };
14217     } catch (Dali::DaliException e) {
14218       {
14219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14220       };
14221     } catch (...) {
14222       {
14223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14224       };
14225     }
14226   }
14227
14228 }
14229
14230
14231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14232   unsigned int jresult ;
14233   Dali::AngleAxis *arg1 = 0 ;
14234   Dali::AngleAxis *arg2 = 0 ;
14235   bool result;
14236
14237   arg1 = (Dali::AngleAxis *)jarg1;
14238   if (!arg1) {
14239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14240     return 0;
14241   }
14242   arg2 = (Dali::AngleAxis *)jarg2;
14243   if (!arg2) {
14244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14245     return 0;
14246   }
14247   {
14248     try {
14249       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14250     } catch (std::out_of_range& e) {
14251       {
14252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14253       };
14254     } catch (std::exception& e) {
14255       {
14256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14257       };
14258     } catch (Dali::DaliException e) {
14259       {
14260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14261       };
14262     } catch (...) {
14263       {
14264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14265       };
14266     }
14267   }
14268
14269   jresult = result;
14270   return jresult;
14271 }
14272
14273
14274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14275   unsigned int jresult ;
14276   unsigned int arg1 ;
14277   unsigned int result;
14278
14279   arg1 = (unsigned int)jarg1;
14280   {
14281     try {
14282       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14283     } catch (std::out_of_range& e) {
14284       {
14285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14286       };
14287     } catch (std::exception& e) {
14288       {
14289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14290       };
14291     } catch (Dali::DaliException e) {
14292       {
14293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14294       };
14295     } catch (...) {
14296       {
14297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14298       };
14299     }
14300   }
14301
14302   jresult = result;
14303   return jresult;
14304 }
14305
14306
14307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14308   unsigned int jresult ;
14309   unsigned int arg1 ;
14310   bool result;
14311
14312   arg1 = (unsigned int)jarg1;
14313   {
14314     try {
14315       result = (bool)Dali::IsPowerOfTwo(arg1);
14316     } catch (std::out_of_range& e) {
14317       {
14318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14319       };
14320     } catch (std::exception& e) {
14321       {
14322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14323       };
14324     } catch (Dali::DaliException e) {
14325       {
14326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14327       };
14328     } catch (...) {
14329       {
14330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14331       };
14332     }
14333   }
14334
14335   jresult = result;
14336   return jresult;
14337 }
14338
14339
14340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14341   float jresult ;
14342   float arg1 ;
14343   float arg2 ;
14344   float result;
14345
14346   arg1 = (float)jarg1;
14347   arg2 = (float)jarg2;
14348   {
14349     try {
14350       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14351     } catch (std::out_of_range& e) {
14352       {
14353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14354       };
14355     } catch (std::exception& e) {
14356       {
14357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14358       };
14359     } catch (Dali::DaliException e) {
14360       {
14361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14362       };
14363     } catch (...) {
14364       {
14365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14366       };
14367     }
14368   }
14369
14370   jresult = result;
14371   return jresult;
14372 }
14373
14374
14375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14376   unsigned int jresult ;
14377   float arg1 ;
14378   bool result;
14379
14380   arg1 = (float)jarg1;
14381   {
14382     try {
14383       result = (bool)Dali::EqualsZero(arg1);
14384     } catch (std::out_of_range& e) {
14385       {
14386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14387       };
14388     } catch (std::exception& e) {
14389       {
14390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14391       };
14392     } catch (Dali::DaliException e) {
14393       {
14394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14395       };
14396     } catch (...) {
14397       {
14398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14399       };
14400     }
14401   }
14402
14403   jresult = result;
14404   return jresult;
14405 }
14406
14407
14408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14409   unsigned int jresult ;
14410   float arg1 ;
14411   float arg2 ;
14412   bool result;
14413
14414   arg1 = (float)jarg1;
14415   arg2 = (float)jarg2;
14416   {
14417     try {
14418       result = (bool)Dali::Equals(arg1,arg2);
14419     } catch (std::out_of_range& e) {
14420       {
14421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (std::exception& e) {
14424       {
14425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14426       };
14427     } catch (Dali::DaliException e) {
14428       {
14429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14430       };
14431     } catch (...) {
14432       {
14433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14434       };
14435     }
14436   }
14437
14438   jresult = result;
14439   return jresult;
14440 }
14441
14442
14443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14444   unsigned int jresult ;
14445   float arg1 ;
14446   float arg2 ;
14447   float arg3 ;
14448   bool result;
14449
14450   arg1 = (float)jarg1;
14451   arg2 = (float)jarg2;
14452   arg3 = (float)jarg3;
14453   {
14454     try {
14455       result = (bool)Dali::Equals(arg1,arg2,arg3);
14456     } catch (std::out_of_range& e) {
14457       {
14458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14459       };
14460     } catch (std::exception& e) {
14461       {
14462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14463       };
14464     } catch (Dali::DaliException e) {
14465       {
14466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14467       };
14468     } catch (...) {
14469       {
14470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14471       };
14472     }
14473   }
14474
14475   jresult = result;
14476   return jresult;
14477 }
14478
14479
14480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14481   float jresult ;
14482   float arg1 ;
14483   int arg2 ;
14484   float result;
14485
14486   arg1 = (float)jarg1;
14487   arg2 = (int)jarg2;
14488   {
14489     try {
14490       result = (float)Dali::Round(arg1,arg2);
14491     } catch (std::out_of_range& e) {
14492       {
14493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14494       };
14495     } catch (std::exception& e) {
14496       {
14497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14498       };
14499     } catch (Dali::DaliException e) {
14500       {
14501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14502       };
14503     } catch (...) {
14504       {
14505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14506       };
14507     }
14508   }
14509
14510   jresult = result;
14511   return jresult;
14512 }
14513
14514
14515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14516   float jresult ;
14517   float arg1 ;
14518   float arg2 ;
14519   float arg3 ;
14520   float result;
14521
14522   arg1 = (float)jarg1;
14523   arg2 = (float)jarg2;
14524   arg3 = (float)jarg3;
14525   {
14526     try {
14527       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14528     } catch (std::out_of_range& e) {
14529       {
14530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14531       };
14532     } catch (std::exception& e) {
14533       {
14534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14535       };
14536     } catch (Dali::DaliException e) {
14537       {
14538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14539       };
14540     } catch (...) {
14541       {
14542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14543       };
14544     }
14545   }
14546
14547   jresult = result;
14548   return jresult;
14549 }
14550
14551
14552 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14553   float jresult ;
14554   float arg1 ;
14555   float arg2 ;
14556   float arg3 ;
14557   float arg4 ;
14558   float result;
14559
14560   arg1 = (float)jarg1;
14561   arg2 = (float)jarg2;
14562   arg3 = (float)jarg3;
14563   arg4 = (float)jarg4;
14564   {
14565     try {
14566       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14567     } catch (std::out_of_range& e) {
14568       {
14569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14570       };
14571     } catch (std::exception& e) {
14572       {
14573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14574       };
14575     } catch (Dali::DaliException e) {
14576       {
14577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14578       };
14579     } catch (...) {
14580       {
14581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14582       };
14583     }
14584   }
14585
14586   jresult = result;
14587   return jresult;
14588 }
14589
14590
14591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14592   int jresult ;
14593   int result;
14594
14595   result = (int)(int)Dali::Property::INVALID_INDEX;
14596   jresult = result;
14597   return jresult;
14598 }
14599
14600
14601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14602   int jresult ;
14603   int result;
14604
14605   result = (int)(int)Dali::Property::INVALID_KEY;
14606   jresult = result;
14607   return jresult;
14608 }
14609
14610
14611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14612   int jresult ;
14613   int result;
14614
14615   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14616   jresult = result;
14617   return jresult;
14618 }
14619
14620
14621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14622   void * jresult ;
14623   Dali::Handle *arg1 = 0 ;
14624   Dali::Property::Index arg2 ;
14625   Dali::Property *result = 0 ;
14626
14627   arg1 = (Dali::Handle *)jarg1;
14628   if (!arg1) {
14629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14630     return 0;
14631   }
14632   arg2 = (Dali::Property::Index)jarg2;
14633   {
14634     try {
14635       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14636     } catch (std::out_of_range& e) {
14637       {
14638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14639       };
14640     } catch (std::exception& e) {
14641       {
14642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14643       };
14644     } catch (Dali::DaliException e) {
14645       {
14646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14647       };
14648     } catch (...) {
14649       {
14650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14651       };
14652     }
14653   }
14654
14655   jresult = (void *)result;
14656   return jresult;
14657 }
14658
14659
14660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14661   void * jresult ;
14662   Dali::Handle *arg1 = 0 ;
14663   Dali::Property::Index arg2 ;
14664   int arg3 ;
14665   Dali::Property *result = 0 ;
14666
14667   arg1 = (Dali::Handle *)jarg1;
14668   if (!arg1) {
14669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14670     return 0;
14671   }
14672   arg2 = (Dali::Property::Index)jarg2;
14673   arg3 = (int)jarg3;
14674   {
14675     try {
14676       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14677     } catch (std::out_of_range& e) {
14678       {
14679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14680       };
14681     } catch (std::exception& e) {
14682       {
14683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14684       };
14685     } catch (Dali::DaliException e) {
14686       {
14687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14688       };
14689     } catch (...) {
14690       {
14691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14692       };
14693     }
14694   }
14695
14696   jresult = (void *)result;
14697   return jresult;
14698 }
14699
14700
14701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14702   void * jresult ;
14703   Dali::Handle *arg1 = 0 ;
14704   std::string *arg2 = 0 ;
14705   Dali::Property *result = 0 ;
14706
14707   arg1 = (Dali::Handle *)jarg1;
14708   if (!arg1) {
14709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14710     return 0;
14711   }
14712   if (!jarg2) {
14713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14714     return 0;
14715   }
14716   std::string arg2_str(jarg2);
14717   arg2 = &arg2_str;
14718   {
14719     try {
14720       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14721     } catch (std::out_of_range& e) {
14722       {
14723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14724       };
14725     } catch (std::exception& e) {
14726       {
14727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14728       };
14729     } catch (Dali::DaliException e) {
14730       {
14731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14732       };
14733     } catch (...) {
14734       {
14735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14736       };
14737     }
14738   }
14739
14740   jresult = (void *)result;
14741
14742   //argout typemap for const std::string&
14743
14744   return jresult;
14745 }
14746
14747
14748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14749   void * jresult ;
14750   Dali::Handle *arg1 = 0 ;
14751   std::string *arg2 = 0 ;
14752   int arg3 ;
14753   Dali::Property *result = 0 ;
14754
14755   arg1 = (Dali::Handle *)jarg1;
14756   if (!arg1) {
14757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14758     return 0;
14759   }
14760   if (!jarg2) {
14761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14762     return 0;
14763   }
14764   std::string arg2_str(jarg2);
14765   arg2 = &arg2_str;
14766   arg3 = (int)jarg3;
14767   {
14768     try {
14769       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14770     } catch (std::out_of_range& e) {
14771       {
14772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14773       };
14774     } catch (std::exception& e) {
14775       {
14776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14777       };
14778     } catch (Dali::DaliException e) {
14779       {
14780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14781       };
14782     } catch (...) {
14783       {
14784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14785       };
14786     }
14787   }
14788
14789   jresult = (void *)result;
14790
14791   //argout typemap for const std::string&
14792
14793   return jresult;
14794 }
14795
14796
14797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14798   Dali::Property *arg1 = (Dali::Property *) 0 ;
14799
14800   arg1 = (Dali::Property *)jarg1;
14801   {
14802     try {
14803       delete arg1;
14804     } catch (std::out_of_range& e) {
14805       {
14806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14807       };
14808     } catch (std::exception& e) {
14809       {
14810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14811       };
14812     } catch (Dali::DaliException e) {
14813       {
14814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14815       };
14816     } catch (...) {
14817       {
14818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14819       };
14820     }
14821   }
14822
14823 }
14824
14825
14826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14827   Dali::Property *arg1 = (Dali::Property *) 0 ;
14828   Dali::Handle *arg2 = 0 ;
14829
14830   arg1 = (Dali::Property *)jarg1;
14831   arg2 = (Dali::Handle *)jarg2;
14832   if (!arg2) {
14833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14834     return ;
14835   }
14836   if (arg1) (arg1)->object = *arg2;
14837 }
14838
14839
14840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14841   void * jresult ;
14842   Dali::Property *arg1 = (Dali::Property *) 0 ;
14843   Dali::Handle *result = 0 ;
14844
14845   arg1 = (Dali::Property *)jarg1;
14846   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14847   jresult = (void *)result;
14848   return jresult;
14849 }
14850
14851
14852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14853   Dali::Property *arg1 = (Dali::Property *) 0 ;
14854   Dali::Property::Index arg2 ;
14855
14856   arg1 = (Dali::Property *)jarg1;
14857   arg2 = (Dali::Property::Index)jarg2;
14858   if (arg1) (arg1)->propertyIndex = arg2;
14859 }
14860
14861
14862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14863   int jresult ;
14864   Dali::Property *arg1 = (Dali::Property *) 0 ;
14865   Dali::Property::Index result;
14866
14867   arg1 = (Dali::Property *)jarg1;
14868   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14869   jresult = result;
14870   return jresult;
14871 }
14872
14873
14874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14875   Dali::Property *arg1 = (Dali::Property *) 0 ;
14876   int arg2 ;
14877
14878   arg1 = (Dali::Property *)jarg1;
14879   arg2 = (int)jarg2;
14880   if (arg1) (arg1)->componentIndex = arg2;
14881 }
14882
14883
14884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14885   int jresult ;
14886   Dali::Property *arg1 = (Dali::Property *) 0 ;
14887   int result;
14888
14889   arg1 = (Dali::Property *)jarg1;
14890   result = (int) ((arg1)->componentIndex);
14891   jresult = result;
14892   return jresult;
14893 }
14894
14895
14896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14897   void * jresult ;
14898   Dali::Property::Array *result = 0 ;
14899
14900   {
14901     try {
14902       result = (Dali::Property::Array *)new Dali::Property::Array();
14903     } catch (std::out_of_range& e) {
14904       {
14905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14906       };
14907     } catch (std::exception& e) {
14908       {
14909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14910       };
14911     } catch (Dali::DaliException e) {
14912       {
14913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14914       };
14915     } catch (...) {
14916       {
14917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14918       };
14919     }
14920   }
14921
14922   jresult = (void *)result;
14923   return jresult;
14924 }
14925
14926
14927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14928   void * jresult ;
14929   Dali::Property::Array *arg1 = 0 ;
14930   Dali::Property::Array *result = 0 ;
14931
14932   arg1 = (Dali::Property::Array *)jarg1;
14933   if (!arg1) {
14934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14935     return 0;
14936   }
14937   {
14938     try {
14939       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14940     } catch (std::out_of_range& e) {
14941       {
14942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (std::exception& e) {
14945       {
14946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14947       };
14948     } catch (Dali::DaliException e) {
14949       {
14950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14951       };
14952     } catch (...) {
14953       {
14954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14955       };
14956     }
14957   }
14958
14959   jresult = (void *)result;
14960   return jresult;
14961 }
14962
14963
14964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14965   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14966
14967   arg1 = (Dali::Property::Array *)jarg1;
14968   {
14969     try {
14970       delete arg1;
14971     } catch (std::out_of_range& e) {
14972       {
14973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14974       };
14975     } catch (std::exception& e) {
14976       {
14977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14978       };
14979     } catch (Dali::DaliException e) {
14980       {
14981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14982       };
14983     } catch (...) {
14984       {
14985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14986       };
14987     }
14988   }
14989
14990 }
14991
14992
14993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14994   unsigned long jresult ;
14995   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14996   Dali::Property::Array::SizeType result;
14997
14998   arg1 = (Dali::Property::Array *)jarg1;
14999   {
15000     try {
15001       result = ((Dali::Property::Array const *)arg1)->Size();
15002     } catch (std::out_of_range& e) {
15003       {
15004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (std::exception& e) {
15007       {
15008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15009       };
15010     } catch (Dali::DaliException e) {
15011       {
15012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15013       };
15014     } catch (...) {
15015       {
15016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15017       };
15018     }
15019   }
15020
15021   jresult = (unsigned long)result;
15022   return jresult;
15023 }
15024
15025
15026 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15027   unsigned long jresult ;
15028   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15029   Dali::Property::Array::SizeType result;
15030
15031   arg1 = (Dali::Property::Array *)jarg1;
15032   {
15033     try {
15034       result = ((Dali::Property::Array const *)arg1)->Count();
15035     } catch (std::out_of_range& e) {
15036       {
15037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (std::exception& e) {
15040       {
15041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15042       };
15043     } catch (Dali::DaliException e) {
15044       {
15045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15046       };
15047     } catch (...) {
15048       {
15049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15050       };
15051     }
15052   }
15053
15054   jresult = (unsigned long)result;
15055   return jresult;
15056 }
15057
15058
15059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15060   unsigned int jresult ;
15061   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15062   bool result;
15063
15064   arg1 = (Dali::Property::Array *)jarg1;
15065   {
15066     try {
15067       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15068     } catch (std::out_of_range& e) {
15069       {
15070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (std::exception& e) {
15073       {
15074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15075       };
15076     } catch (Dali::DaliException e) {
15077       {
15078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15079       };
15080     } catch (...) {
15081       {
15082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15083       };
15084     }
15085   }
15086
15087   jresult = result;
15088   return jresult;
15089 }
15090
15091
15092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15093   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15094
15095   arg1 = (Dali::Property::Array *)jarg1;
15096   {
15097     try {
15098       (arg1)->Clear();
15099     } catch (std::out_of_range& e) {
15100       {
15101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15102       };
15103     } catch (std::exception& e) {
15104       {
15105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15106       };
15107     } catch (Dali::DaliException e) {
15108       {
15109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15110       };
15111     } catch (...) {
15112       {
15113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15114       };
15115     }
15116   }
15117
15118 }
15119
15120
15121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15122   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15123   Dali::Property::Array::SizeType arg2 ;
15124
15125   arg1 = (Dali::Property::Array *)jarg1;
15126   arg2 = (Dali::Property::Array::SizeType)jarg2;
15127   {
15128     try {
15129       (arg1)->Reserve(arg2);
15130     } catch (std::out_of_range& e) {
15131       {
15132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15133       };
15134     } catch (std::exception& e) {
15135       {
15136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15137       };
15138     } catch (Dali::DaliException e) {
15139       {
15140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15141       };
15142     } catch (...) {
15143       {
15144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15145       };
15146     }
15147   }
15148
15149 }
15150
15151
15152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15153   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15154   Dali::Property::Array::SizeType arg2 ;
15155
15156   arg1 = (Dali::Property::Array *)jarg1;
15157   arg2 = (Dali::Property::Array::SizeType)jarg2;
15158   {
15159     try {
15160       (arg1)->Resize(arg2);
15161     } catch (std::out_of_range& e) {
15162       {
15163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15164       };
15165     } catch (std::exception& e) {
15166       {
15167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15168       };
15169     } catch (Dali::DaliException e) {
15170       {
15171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15172       };
15173     } catch (...) {
15174       {
15175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15176       };
15177     }
15178   }
15179
15180 }
15181
15182
15183 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15184   unsigned long jresult ;
15185   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15186   Dali::Property::Array::SizeType result;
15187
15188   arg1 = (Dali::Property::Array *)jarg1;
15189   {
15190     try {
15191       result = (arg1)->Capacity();
15192     } catch (std::out_of_range& e) {
15193       {
15194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15195       };
15196     } catch (std::exception& e) {
15197       {
15198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15199       };
15200     } catch (Dali::DaliException e) {
15201       {
15202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15203       };
15204     } catch (...) {
15205       {
15206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15207       };
15208     }
15209   }
15210
15211   jresult = (unsigned long)result;
15212   return jresult;
15213 }
15214
15215
15216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15217   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15218   Dali::Property::Value *arg2 = 0 ;
15219
15220   arg1 = (Dali::Property::Array *)jarg1;
15221   arg2 = (Dali::Property::Value *)jarg2;
15222   if (!arg2) {
15223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15224     return ;
15225   }
15226   {
15227     try {
15228       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15229     } catch (std::out_of_range& e) {
15230       {
15231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15232       };
15233     } catch (std::exception& e) {
15234       {
15235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15236       };
15237     } catch (Dali::DaliException e) {
15238       {
15239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15240       };
15241     } catch (...) {
15242       {
15243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15244       };
15245     }
15246   }
15247
15248 }
15249
15250
15251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15252   void * jresult ;
15253   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15254   Dali::Property::Value *arg2 = 0 ;
15255   Dali::Property::Array *result = 0 ;
15256
15257   arg1 = (Dali::Property::Array *)jarg1;
15258   arg2 = (Dali::Property::Value *)jarg2;
15259   if (!arg2) {
15260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15261     return 0;
15262   }
15263   {
15264     try {
15265       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15266     } catch (std::out_of_range& e) {
15267       {
15268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15269       };
15270     } catch (std::exception& e) {
15271       {
15272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15273       };
15274     } catch (Dali::DaliException e) {
15275       {
15276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15277       };
15278     } catch (...) {
15279       {
15280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15281       };
15282     }
15283   }
15284
15285   jresult = (void *)result;
15286   return jresult;
15287 }
15288
15289
15290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15291   void * jresult ;
15292   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15293   Dali::Property::Array::SizeType arg2 ;
15294   Dali::Property::Value *result = 0 ;
15295
15296   arg1 = (Dali::Property::Array *)jarg1;
15297   arg2 = (Dali::Property::Array::SizeType)jarg2;
15298   {
15299     try {
15300       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15301     } catch (std::out_of_range& e) {
15302       {
15303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15304       };
15305     } catch (std::exception& e) {
15306       {
15307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15308       };
15309     } catch (Dali::DaliException e) {
15310       {
15311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15312       };
15313     } catch (...) {
15314       {
15315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15316       };
15317     }
15318   }
15319
15320   jresult = (void *)result;
15321   return jresult;
15322 }
15323
15324
15325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15326   void * jresult ;
15327   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15328   Dali::Property::Array::SizeType arg2 ;
15329   Dali::Property::Value *result = 0 ;
15330
15331   arg1 = (Dali::Property::Array *)jarg1;
15332   arg2 = (Dali::Property::Array::SizeType)jarg2;
15333   {
15334     try {
15335       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15336     } catch (std::out_of_range& e) {
15337       {
15338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15339       };
15340     } catch (std::exception& e) {
15341       {
15342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15343       };
15344     } catch (Dali::DaliException e) {
15345       {
15346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15347       };
15348     } catch (...) {
15349       {
15350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15351       };
15352     }
15353   }
15354
15355   jresult = (void *)result;
15356   return jresult;
15357 }
15358
15359
15360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15361   void * jresult ;
15362   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15363   Dali::Property::Array *arg2 = 0 ;
15364   Dali::Property::Array *result = 0 ;
15365
15366   arg1 = (Dali::Property::Array *)jarg1;
15367   arg2 = (Dali::Property::Array *)jarg2;
15368   if (!arg2) {
15369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15370     return 0;
15371   }
15372   {
15373     try {
15374       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15375     } catch (std::out_of_range& e) {
15376       {
15377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15378       };
15379     } catch (std::exception& e) {
15380       {
15381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15382       };
15383     } catch (Dali::DaliException e) {
15384       {
15385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15386       };
15387     } catch (...) {
15388       {
15389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15390       };
15391     }
15392   }
15393
15394   jresult = (void *)result;
15395   return jresult;
15396 }
15397
15398
15399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15400   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15401   enum Dali::Property::Key::Type arg2 ;
15402
15403   arg1 = (Dali::Property::Key *)jarg1;
15404   arg2 = (enum Dali::Property::Key::Type)jarg2;
15405   if (arg1) (arg1)->type = arg2;
15406 }
15407
15408
15409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15410   int jresult ;
15411   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15412   enum Dali::Property::Key::Type result;
15413
15414   arg1 = (Dali::Property::Key *)jarg1;
15415   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15416   jresult = (int)result;
15417   return jresult;
15418 }
15419
15420
15421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15422   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15423   Dali::Property::Index arg2 ;
15424
15425   arg1 = (Dali::Property::Key *)jarg1;
15426   arg2 = (Dali::Property::Index)jarg2;
15427   if (arg1) (arg1)->indexKey = arg2;
15428 }
15429
15430
15431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15432   int jresult ;
15433   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15434   Dali::Property::Index result;
15435
15436   arg1 = (Dali::Property::Key *)jarg1;
15437   result = (Dali::Property::Index) ((arg1)->indexKey);
15438   jresult = result;
15439   return jresult;
15440 }
15441
15442
15443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15444   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15445   std::string *arg2 = 0 ;
15446
15447   arg1 = (Dali::Property::Key *)jarg1;
15448   if (!jarg2) {
15449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15450     return ;
15451   }
15452   std::string arg2_str(jarg2);
15453   arg2 = &arg2_str;
15454   if (arg1) (arg1)->stringKey = *arg2;
15455
15456   //argout typemap for const std::string&
15457
15458 }
15459
15460
15461 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15462   char * jresult ;
15463   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15464   std::string *result = 0 ;
15465
15466   arg1 = (Dali::Property::Key *)jarg1;
15467   result = (std::string *) & ((arg1)->stringKey);
15468   jresult = SWIG_csharp_string_callback(result->c_str());
15469   return jresult;
15470 }
15471
15472
15473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15474   void * jresult ;
15475   std::string *arg1 = 0 ;
15476   Dali::Property::Key *result = 0 ;
15477
15478   if (!jarg1) {
15479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15480     return 0;
15481   }
15482   std::string arg1_str(jarg1);
15483   arg1 = &arg1_str;
15484   {
15485     try {
15486       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15487     } catch (std::out_of_range& e) {
15488       {
15489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15490       };
15491     } catch (std::exception& e) {
15492       {
15493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15494       };
15495     } catch (Dali::DaliException e) {
15496       {
15497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15498       };
15499     } catch (...) {
15500       {
15501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15502       };
15503     }
15504   }
15505
15506   jresult = (void *)result;
15507
15508   //argout typemap for const std::string&
15509
15510   return jresult;
15511 }
15512
15513
15514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15515   void * jresult ;
15516   Dali::Property::Index arg1 ;
15517   Dali::Property::Key *result = 0 ;
15518
15519   arg1 = (Dali::Property::Index)jarg1;
15520   {
15521     try {
15522       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15523     } catch (std::out_of_range& e) {
15524       {
15525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15526       };
15527     } catch (std::exception& e) {
15528       {
15529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15530       };
15531     } catch (Dali::DaliException e) {
15532       {
15533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15534       };
15535     } catch (...) {
15536       {
15537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15538       };
15539     }
15540   }
15541
15542   jresult = (void *)result;
15543   return jresult;
15544 }
15545
15546
15547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15548   unsigned int jresult ;
15549   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15550   std::string *arg2 = 0 ;
15551   bool result;
15552
15553   arg1 = (Dali::Property::Key *)jarg1;
15554   if (!jarg2) {
15555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15556     return 0;
15557   }
15558   std::string arg2_str(jarg2);
15559   arg2 = &arg2_str;
15560   {
15561     try {
15562       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15563     } catch (std::out_of_range& e) {
15564       {
15565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15566       };
15567     } catch (std::exception& e) {
15568       {
15569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15570       };
15571     } catch (Dali::DaliException e) {
15572       {
15573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15574       };
15575     } catch (...) {
15576       {
15577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15578       };
15579     }
15580   }
15581
15582   jresult = result;
15583
15584   //argout typemap for const std::string&
15585
15586   return jresult;
15587 }
15588
15589
15590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15591   unsigned int jresult ;
15592   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15593   Dali::Property::Index arg2 ;
15594   bool result;
15595
15596   arg1 = (Dali::Property::Key *)jarg1;
15597   arg2 = (Dali::Property::Index)jarg2;
15598   {
15599     try {
15600       result = (bool)(arg1)->operator ==(arg2);
15601     } catch (std::out_of_range& e) {
15602       {
15603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15604       };
15605     } catch (std::exception& e) {
15606       {
15607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15608       };
15609     } catch (Dali::DaliException e) {
15610       {
15611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15612       };
15613     } catch (...) {
15614       {
15615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15616       };
15617     }
15618   }
15619
15620   jresult = result;
15621   return jresult;
15622 }
15623
15624
15625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15626   unsigned int jresult ;
15627   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15628   Dali::Property::Key *arg2 = 0 ;
15629   bool result;
15630
15631   arg1 = (Dali::Property::Key *)jarg1;
15632   arg2 = (Dali::Property::Key *)jarg2;
15633   if (!arg2) {
15634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15635     return 0;
15636   }
15637   {
15638     try {
15639       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15640     } catch (std::out_of_range& e) {
15641       {
15642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15643       };
15644     } catch (std::exception& e) {
15645       {
15646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15647       };
15648     } catch (Dali::DaliException e) {
15649       {
15650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15651       };
15652     } catch (...) {
15653       {
15654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15655       };
15656     }
15657   }
15658
15659   jresult = result;
15660   return jresult;
15661 }
15662
15663
15664 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15665   unsigned int jresult ;
15666   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15667   std::string *arg2 = 0 ;
15668   bool result;
15669
15670   arg1 = (Dali::Property::Key *)jarg1;
15671   if (!jarg2) {
15672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15673     return 0;
15674   }
15675   std::string arg2_str(jarg2);
15676   arg2 = &arg2_str;
15677   {
15678     try {
15679       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15680     } catch (std::out_of_range& e) {
15681       {
15682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15683       };
15684     } catch (std::exception& e) {
15685       {
15686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15687       };
15688     } catch (Dali::DaliException e) {
15689       {
15690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15691       };
15692     } catch (...) {
15693       {
15694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15695       };
15696     }
15697   }
15698
15699   jresult = result;
15700
15701   //argout typemap for const std::string&
15702
15703   return jresult;
15704 }
15705
15706
15707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15708   unsigned int jresult ;
15709   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15710   Dali::Property::Index arg2 ;
15711   bool result;
15712
15713   arg1 = (Dali::Property::Key *)jarg1;
15714   arg2 = (Dali::Property::Index)jarg2;
15715   {
15716     try {
15717       result = (bool)(arg1)->operator !=(arg2);
15718     } catch (std::out_of_range& e) {
15719       {
15720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15721       };
15722     } catch (std::exception& e) {
15723       {
15724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15725       };
15726     } catch (Dali::DaliException e) {
15727       {
15728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15729       };
15730     } catch (...) {
15731       {
15732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15733       };
15734     }
15735   }
15736
15737   jresult = result;
15738   return jresult;
15739 }
15740
15741
15742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15743   unsigned int jresult ;
15744   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15745   Dali::Property::Key *arg2 = 0 ;
15746   bool result;
15747
15748   arg1 = (Dali::Property::Key *)jarg1;
15749   arg2 = (Dali::Property::Key *)jarg2;
15750   if (!arg2) {
15751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15752     return 0;
15753   }
15754   {
15755     try {
15756       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15757     } catch (std::out_of_range& e) {
15758       {
15759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15760       };
15761     } catch (std::exception& e) {
15762       {
15763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15764       };
15765     } catch (Dali::DaliException e) {
15766       {
15767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15768       };
15769     } catch (...) {
15770       {
15771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15772       };
15773     }
15774   }
15775
15776   jresult = result;
15777   return jresult;
15778 }
15779
15780
15781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15782   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15783
15784   arg1 = (Dali::Property::Key *)jarg1;
15785   {
15786     try {
15787       delete arg1;
15788     } catch (std::out_of_range& e) {
15789       {
15790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15791       };
15792     } catch (std::exception& e) {
15793       {
15794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15795       };
15796     } catch (Dali::DaliException e) {
15797       {
15798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15799       };
15800     } catch (...) {
15801       {
15802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15803       };
15804     }
15805   }
15806
15807 }
15808
15809
15810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15811   void * jresult ;
15812   Dali::Property::Map *result = 0 ;
15813
15814   {
15815     try {
15816       result = (Dali::Property::Map *)new Dali::Property::Map();
15817     } catch (std::out_of_range& e) {
15818       {
15819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15820       };
15821     } catch (std::exception& e) {
15822       {
15823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15824       };
15825     } catch (Dali::DaliException e) {
15826       {
15827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15828       };
15829     } catch (...) {
15830       {
15831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15832       };
15833     }
15834   }
15835
15836   jresult = (void *)result;
15837   return jresult;
15838 }
15839
15840
15841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15842   void * jresult ;
15843   Dali::Property::Map *arg1 = 0 ;
15844   Dali::Property::Map *result = 0 ;
15845
15846   arg1 = (Dali::Property::Map *)jarg1;
15847   if (!arg1) {
15848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15849     return 0;
15850   }
15851   {
15852     try {
15853       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15854     } catch (std::out_of_range& e) {
15855       {
15856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15857       };
15858     } catch (std::exception& e) {
15859       {
15860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15861       };
15862     } catch (Dali::DaliException e) {
15863       {
15864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15865       };
15866     } catch (...) {
15867       {
15868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15869       };
15870     }
15871   }
15872
15873   jresult = (void *)result;
15874   return jresult;
15875 }
15876
15877
15878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15879   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15880
15881   arg1 = (Dali::Property::Map *)jarg1;
15882   {
15883     try {
15884       delete arg1;
15885     } catch (std::out_of_range& e) {
15886       {
15887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15888       };
15889     } catch (std::exception& e) {
15890       {
15891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15892       };
15893     } catch (Dali::DaliException e) {
15894       {
15895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15896       };
15897     } catch (...) {
15898       {
15899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15900       };
15901     }
15902   }
15903
15904 }
15905
15906
15907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15908   unsigned long jresult ;
15909   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15910   Dali::Property::Map::SizeType result;
15911
15912   arg1 = (Dali::Property::Map *)jarg1;
15913   {
15914     try {
15915       result = ((Dali::Property::Map const *)arg1)->Count();
15916     } catch (std::out_of_range& e) {
15917       {
15918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15919       };
15920     } catch (std::exception& e) {
15921       {
15922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15923       };
15924     } catch (Dali::DaliException e) {
15925       {
15926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15927       };
15928     } catch (...) {
15929       {
15930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15931       };
15932     }
15933   }
15934
15935   jresult = (unsigned long)result;
15936   return jresult;
15937 }
15938
15939
15940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15941   unsigned int jresult ;
15942   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15943   bool result;
15944
15945   arg1 = (Dali::Property::Map *)jarg1;
15946   {
15947     try {
15948       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15949     } catch (std::out_of_range& e) {
15950       {
15951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15952       };
15953     } catch (std::exception& e) {
15954       {
15955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15956       };
15957     } catch (Dali::DaliException e) {
15958       {
15959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15960       };
15961     } catch (...) {
15962       {
15963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15964       };
15965     }
15966   }
15967
15968   jresult = result;
15969   return jresult;
15970 }
15971
15972
15973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15974   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15975   char *arg2 = (char *) 0 ;
15976   Dali::Property::Value *arg3 = 0 ;
15977
15978   arg1 = (Dali::Property::Map *)jarg1;
15979   arg2 = (char *)jarg2;
15980   arg3 = (Dali::Property::Value *)jarg3;
15981   if (!arg3) {
15982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15983     return ;
15984   }
15985   {
15986     try {
15987       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15988     } catch (std::out_of_range& e) {
15989       {
15990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15991       };
15992     } catch (std::exception& e) {
15993       {
15994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15995       };
15996     } catch (Dali::DaliException e) {
15997       {
15998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15999       };
16000     } catch (...) {
16001       {
16002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16003       };
16004     }
16005   }
16006
16007 }
16008
16009
16010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16011   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16012   Dali::Property::Index arg2 ;
16013   Dali::Property::Value *arg3 = 0 ;
16014
16015   arg1 = (Dali::Property::Map *)jarg1;
16016   arg2 = (Dali::Property::Index)jarg2;
16017   arg3 = (Dali::Property::Value *)jarg3;
16018   if (!arg3) {
16019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16020     return ;
16021   }
16022   {
16023     try {
16024       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16025     } catch (std::out_of_range& e) {
16026       {
16027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16028       };
16029     } catch (std::exception& e) {
16030       {
16031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16032       };
16033     } catch (Dali::DaliException e) {
16034       {
16035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16036       };
16037     } catch (...) {
16038       {
16039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16040       };
16041     }
16042   }
16043
16044 }
16045
16046
16047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16048   void * jresult ;
16049   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16050   char *arg2 = (char *) 0 ;
16051   Dali::Property::Value *arg3 = 0 ;
16052   Dali::Property::Map *result = 0 ;
16053
16054   arg1 = (Dali::Property::Map *)jarg1;
16055   arg2 = (char *)jarg2;
16056   arg3 = (Dali::Property::Value *)jarg3;
16057   if (!arg3) {
16058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16059     return 0;
16060   }
16061   {
16062     try {
16063       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16064     } catch (std::out_of_range& e) {
16065       {
16066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16067       };
16068     } catch (std::exception& e) {
16069       {
16070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16071       };
16072     } catch (Dali::DaliException e) {
16073       {
16074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16075       };
16076     } catch (...) {
16077       {
16078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16079       };
16080     }
16081   }
16082
16083   jresult = (void *)result;
16084   return jresult;
16085 }
16086
16087
16088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16089   void * jresult ;
16090   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16091   Dali::Property::Index arg2 ;
16092   Dali::Property::Value *arg3 = 0 ;
16093   Dali::Property::Map *result = 0 ;
16094
16095   arg1 = (Dali::Property::Map *)jarg1;
16096   arg2 = (Dali::Property::Index)jarg2;
16097   arg3 = (Dali::Property::Value *)jarg3;
16098   if (!arg3) {
16099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16100     return 0;
16101   }
16102   {
16103     try {
16104       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16105     } catch (std::out_of_range& e) {
16106       {
16107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16108       };
16109     } catch (std::exception& e) {
16110       {
16111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16112       };
16113     } catch (Dali::DaliException e) {
16114       {
16115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16116       };
16117     } catch (...) {
16118       {
16119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16120       };
16121     }
16122   }
16123
16124   jresult = (void *)result;
16125   return jresult;
16126 }
16127
16128
16129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16130   void * jresult ;
16131   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16132   Dali::Property::Map::SizeType arg2 ;
16133   Dali::Property::Value *result = 0 ;
16134
16135   arg1 = (Dali::Property::Map *)jarg1;
16136   arg2 = (Dali::Property::Map::SizeType)jarg2;
16137   {
16138     try {
16139       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16140     } catch (std::out_of_range& e) {
16141       {
16142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16143       };
16144     } catch (std::exception& e) {
16145       {
16146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16147       };
16148     } catch (Dali::DaliException e) {
16149       {
16150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16151       };
16152     } catch (...) {
16153       {
16154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16155       };
16156     }
16157   }
16158
16159   jresult = (void *)result;
16160   return jresult;
16161 }
16162
16163
16164 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16165   char * jresult ;
16166   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16167   Dali::Property::Map::SizeType arg2 ;
16168   std::string *result = 0 ;
16169
16170   arg1 = (Dali::Property::Map *)jarg1;
16171   arg2 = (Dali::Property::Map::SizeType)jarg2;
16172   {
16173     try {
16174       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16175     } catch (std::out_of_range& e) {
16176       {
16177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16178       };
16179     } catch (std::exception& e) {
16180       {
16181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16182       };
16183     } catch (Dali::DaliException e) {
16184       {
16185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16186       };
16187     } catch (...) {
16188       {
16189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16190       };
16191     }
16192   }
16193
16194   jresult = SWIG_csharp_string_callback(result->c_str());
16195   return jresult;
16196 }
16197
16198
16199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16200   void * jresult ;
16201   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16202   Dali::Property::Map::SizeType arg2 ;
16203   SwigValueWrapper< Dali::Property::Key > result;
16204
16205   arg1 = (Dali::Property::Map *)jarg1;
16206   arg2 = (Dali::Property::Map::SizeType)jarg2;
16207   {
16208     try {
16209       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16210     } catch (std::out_of_range& e) {
16211       {
16212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16213       };
16214     } catch (std::exception& e) {
16215       {
16216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16217       };
16218     } catch (Dali::DaliException e) {
16219       {
16220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16221       };
16222     } catch (...) {
16223       {
16224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16225       };
16226     }
16227   }
16228
16229   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16230   return jresult;
16231 }
16232
16233
16234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16235   void * jresult ;
16236   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16237   Dali::Property::Map::SizeType arg2 ;
16238   StringValuePair *result = 0 ;
16239
16240   arg1 = (Dali::Property::Map *)jarg1;
16241   arg2 = (Dali::Property::Map::SizeType)jarg2;
16242   {
16243     try {
16244       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16245     } catch (std::out_of_range& e) {
16246       {
16247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16248       };
16249     } catch (std::exception& e) {
16250       {
16251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16252       };
16253     } catch (Dali::DaliException e) {
16254       {
16255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16256       };
16257     } catch (...) {
16258       {
16259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16260       };
16261     }
16262   }
16263
16264   jresult = (void *)result;
16265   return jresult;
16266 }
16267
16268
16269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16270   void * jresult ;
16271   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16272   char *arg2 = (char *) 0 ;
16273   Dali::Property::Value *result = 0 ;
16274
16275   arg1 = (Dali::Property::Map *)jarg1;
16276   arg2 = (char *)jarg2;
16277   {
16278     try {
16279       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16280     } catch (std::out_of_range& e) {
16281       {
16282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16283       };
16284     } catch (std::exception& e) {
16285       {
16286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16287       };
16288     } catch (Dali::DaliException e) {
16289       {
16290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16291       };
16292     } catch (...) {
16293       {
16294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16295       };
16296     }
16297   }
16298
16299   jresult = (void *)result;
16300   return jresult;
16301 }
16302
16303
16304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16305   void * jresult ;
16306   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16307   Dali::Property::Index arg2 ;
16308   Dali::Property::Value *result = 0 ;
16309
16310   arg1 = (Dali::Property::Map *)jarg1;
16311   arg2 = (Dali::Property::Index)jarg2;
16312   {
16313     try {
16314       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16315     } catch (std::out_of_range& e) {
16316       {
16317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16318       };
16319     } catch (std::exception& e) {
16320       {
16321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16322       };
16323     } catch (Dali::DaliException e) {
16324       {
16325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16326       };
16327     } catch (...) {
16328       {
16329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16330       };
16331     }
16332   }
16333
16334   jresult = (void *)result;
16335   return jresult;
16336 }
16337
16338
16339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16340   void * jresult ;
16341   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16342   Dali::Property::Index arg2 ;
16343   std::string *arg3 = 0 ;
16344   Dali::Property::Value *result = 0 ;
16345
16346   arg1 = (Dali::Property::Map *)jarg1;
16347   arg2 = (Dali::Property::Index)jarg2;
16348   if (!jarg3) {
16349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16350     return 0;
16351   }
16352   std::string arg3_str(jarg3);
16353   arg3 = &arg3_str;
16354   {
16355     try {
16356       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16357     } catch (std::out_of_range& e) {
16358       {
16359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16360       };
16361     } catch (std::exception& e) {
16362       {
16363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16364       };
16365     } catch (Dali::DaliException e) {
16366       {
16367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16368       };
16369     } catch (...) {
16370       {
16371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16372       };
16373     }
16374   }
16375
16376   jresult = (void *)result;
16377
16378   //argout typemap for const std::string&
16379
16380   return jresult;
16381 }
16382
16383
16384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16385   void * jresult ;
16386   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16387   std::string *arg2 = 0 ;
16388   Dali::Property::Type arg3 ;
16389   Dali::Property::Value *result = 0 ;
16390
16391   arg1 = (Dali::Property::Map *)jarg1;
16392   if (!jarg2) {
16393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16394     return 0;
16395   }
16396   std::string arg2_str(jarg2);
16397   arg2 = &arg2_str;
16398   arg3 = (Dali::Property::Type)jarg3;
16399   {
16400     try {
16401       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16402     } catch (std::out_of_range& e) {
16403       {
16404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16405       };
16406     } catch (std::exception& e) {
16407       {
16408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16409       };
16410     } catch (Dali::DaliException e) {
16411       {
16412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16413       };
16414     } catch (...) {
16415       {
16416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16417       };
16418     }
16419   }
16420
16421   jresult = (void *)result;
16422
16423   //argout typemap for const std::string&
16424
16425   return jresult;
16426 }
16427
16428
16429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16430   void * jresult ;
16431   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16432   Dali::Property::Index arg2 ;
16433   Dali::Property::Type arg3 ;
16434   Dali::Property::Value *result = 0 ;
16435
16436   arg1 = (Dali::Property::Map *)jarg1;
16437   arg2 = (Dali::Property::Index)jarg2;
16438   arg3 = (Dali::Property::Type)jarg3;
16439   {
16440     try {
16441       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16442     } catch (std::out_of_range& e) {
16443       {
16444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16445       };
16446     } catch (std::exception& e) {
16447       {
16448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16449       };
16450     } catch (Dali::DaliException e) {
16451       {
16452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16453       };
16454     } catch (...) {
16455       {
16456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16457       };
16458     }
16459   }
16460
16461   jresult = (void *)result;
16462   return jresult;
16463 }
16464
16465
16466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16467   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16468
16469   arg1 = (Dali::Property::Map *)jarg1;
16470   {
16471     try {
16472       (arg1)->Clear();
16473     } catch (std::out_of_range& e) {
16474       {
16475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16476       };
16477     } catch (std::exception& e) {
16478       {
16479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16480       };
16481     } catch (Dali::DaliException e) {
16482       {
16483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16484       };
16485     } catch (...) {
16486       {
16487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16488       };
16489     }
16490   }
16491
16492 }
16493
16494
16495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16496   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16497   Dali::Property::Map *arg2 = 0 ;
16498
16499   arg1 = (Dali::Property::Map *)jarg1;
16500   arg2 = (Dali::Property::Map *)jarg2;
16501   if (!arg2) {
16502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16503     return ;
16504   }
16505   {
16506     try {
16507       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16508     } catch (std::out_of_range& e) {
16509       {
16510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16511       };
16512     } catch (std::exception& e) {
16513       {
16514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16515       };
16516     } catch (Dali::DaliException e) {
16517       {
16518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16519       };
16520     } catch (...) {
16521       {
16522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16523       };
16524     }
16525   }
16526
16527 }
16528
16529
16530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16531   void * jresult ;
16532   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16533   std::string *arg2 = 0 ;
16534   Dali::Property::Value *result = 0 ;
16535
16536   arg1 = (Dali::Property::Map *)jarg1;
16537   if (!jarg2) {
16538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16539     return 0;
16540   }
16541   std::string arg2_str(jarg2);
16542   arg2 = &arg2_str;
16543   {
16544     try {
16545       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16546     } catch (std::out_of_range& e) {
16547       {
16548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16549       };
16550     } catch (std::exception& e) {
16551       {
16552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16553       };
16554     } catch (Dali::DaliException e) {
16555       {
16556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16557       };
16558     } catch (...) {
16559       {
16560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16561       };
16562     }
16563   }
16564
16565   jresult = (void *)result;
16566
16567   //argout typemap for const std::string&
16568
16569   return jresult;
16570 }
16571
16572
16573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16574   void * jresult ;
16575   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16576   Dali::Property::Index arg2 ;
16577   Dali::Property::Value *result = 0 ;
16578
16579   arg1 = (Dali::Property::Map *)jarg1;
16580   arg2 = (Dali::Property::Index)jarg2;
16581   {
16582     try {
16583       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16584     } catch (std::out_of_range& e) {
16585       {
16586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16587       };
16588     } catch (std::exception& e) {
16589       {
16590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16591       };
16592     } catch (Dali::DaliException e) {
16593       {
16594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16595       };
16596     } catch (...) {
16597       {
16598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16599       };
16600     }
16601   }
16602
16603   jresult = (void *)result;
16604   return jresult;
16605 }
16606
16607
16608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16609   void * jresult ;
16610   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16611   Dali::Property::Map *arg2 = 0 ;
16612   Dali::Property::Map *result = 0 ;
16613
16614   arg1 = (Dali::Property::Map *)jarg1;
16615   arg2 = (Dali::Property::Map *)jarg2;
16616   if (!arg2) {
16617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16618     return 0;
16619   }
16620   {
16621     try {
16622       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16623     } catch (std::out_of_range& e) {
16624       {
16625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16626       };
16627     } catch (std::exception& e) {
16628       {
16629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16630       };
16631     } catch (Dali::DaliException e) {
16632       {
16633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16634       };
16635     } catch (...) {
16636       {
16637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16638       };
16639     }
16640   }
16641
16642   jresult = (void *)result;
16643   return jresult;
16644 }
16645
16646
16647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16648   void * jresult ;
16649   Dali::Property::Value *result = 0 ;
16650
16651   {
16652     try {
16653       result = (Dali::Property::Value *)new Dali::Property::Value();
16654     } catch (std::out_of_range& e) {
16655       {
16656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16657       };
16658     } catch (std::exception& e) {
16659       {
16660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16661       };
16662     } catch (Dali::DaliException e) {
16663       {
16664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16665       };
16666     } catch (...) {
16667       {
16668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16669       };
16670     }
16671   }
16672
16673   jresult = (void *)result;
16674   return jresult;
16675 }
16676
16677
16678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16679   void * jresult ;
16680   bool arg1 ;
16681   Dali::Property::Value *result = 0 ;
16682
16683   arg1 = jarg1 ? true : false;
16684   {
16685     try {
16686       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16687     } catch (std::out_of_range& e) {
16688       {
16689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16690       };
16691     } catch (std::exception& e) {
16692       {
16693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16694       };
16695     } catch (Dali::DaliException e) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16698       };
16699     } catch (...) {
16700       {
16701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16702       };
16703     }
16704   }
16705
16706   jresult = (void *)result;
16707   return jresult;
16708 }
16709
16710
16711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16712   void * jresult ;
16713   int arg1 ;
16714   Dali::Property::Value *result = 0 ;
16715
16716   arg1 = (int)jarg1;
16717   {
16718     try {
16719       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16720     } catch (std::out_of_range& e) {
16721       {
16722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16723       };
16724     } catch (std::exception& e) {
16725       {
16726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16727       };
16728     } catch (Dali::DaliException e) {
16729       {
16730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16731       };
16732     } catch (...) {
16733       {
16734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16735       };
16736     }
16737   }
16738
16739   jresult = (void *)result;
16740   return jresult;
16741 }
16742
16743
16744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16745   void * jresult ;
16746   float arg1 ;
16747   Dali::Property::Value *result = 0 ;
16748
16749   arg1 = (float)jarg1;
16750   {
16751     try {
16752       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16753     } catch (std::out_of_range& e) {
16754       {
16755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16756       };
16757     } catch (std::exception& e) {
16758       {
16759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16760       };
16761     } catch (Dali::DaliException e) {
16762       {
16763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16764       };
16765     } catch (...) {
16766       {
16767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16768       };
16769     }
16770   }
16771
16772   jresult = (void *)result;
16773   return jresult;
16774 }
16775
16776
16777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16778   void * jresult ;
16779   Dali::Vector2 *arg1 = 0 ;
16780   Dali::Property::Value *result = 0 ;
16781
16782   arg1 = (Dali::Vector2 *)jarg1;
16783   if (!arg1) {
16784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16785     return 0;
16786   }
16787   {
16788     try {
16789       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16790     } catch (std::out_of_range& e) {
16791       {
16792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16793       };
16794     } catch (std::exception& e) {
16795       {
16796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16797       };
16798     } catch (Dali::DaliException e) {
16799       {
16800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16801       };
16802     } catch (...) {
16803       {
16804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16805       };
16806     }
16807   }
16808
16809   jresult = (void *)result;
16810   return jresult;
16811 }
16812
16813
16814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16815   void * jresult ;
16816   Dali::Vector3 *arg1 = 0 ;
16817   Dali::Property::Value *result = 0 ;
16818
16819   arg1 = (Dali::Vector3 *)jarg1;
16820   if (!arg1) {
16821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16822     return 0;
16823   }
16824   {
16825     try {
16826       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16827     } catch (std::out_of_range& e) {
16828       {
16829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16830       };
16831     } catch (std::exception& e) {
16832       {
16833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16834       };
16835     } catch (Dali::DaliException e) {
16836       {
16837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16838       };
16839     } catch (...) {
16840       {
16841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16842       };
16843     }
16844   }
16845
16846   jresult = (void *)result;
16847   return jresult;
16848 }
16849
16850
16851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16852   void * jresult ;
16853   Dali::Vector4 *arg1 = 0 ;
16854   Dali::Property::Value *result = 0 ;
16855
16856   arg1 = (Dali::Vector4 *)jarg1;
16857   if (!arg1) {
16858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16859     return 0;
16860   }
16861   {
16862     try {
16863       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16864     } catch (std::out_of_range& e) {
16865       {
16866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16867       };
16868     } catch (std::exception& e) {
16869       {
16870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16871       };
16872     } catch (Dali::DaliException e) {
16873       {
16874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16875       };
16876     } catch (...) {
16877       {
16878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16879       };
16880     }
16881   }
16882
16883   jresult = (void *)result;
16884   return jresult;
16885 }
16886
16887
16888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16889   void * jresult ;
16890   Dali::Matrix3 *arg1 = 0 ;
16891   Dali::Property::Value *result = 0 ;
16892
16893   arg1 = (Dali::Matrix3 *)jarg1;
16894   if (!arg1) {
16895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16896     return 0;
16897   }
16898   {
16899     try {
16900       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16901     } catch (std::out_of_range& e) {
16902       {
16903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16904       };
16905     } catch (std::exception& e) {
16906       {
16907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16908       };
16909     } catch (Dali::DaliException e) {
16910       {
16911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16912       };
16913     } catch (...) {
16914       {
16915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16916       };
16917     }
16918   }
16919
16920   jresult = (void *)result;
16921   return jresult;
16922 }
16923
16924
16925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16926   void * jresult ;
16927   Dali::Matrix *arg1 = 0 ;
16928   Dali::Property::Value *result = 0 ;
16929
16930   arg1 = (Dali::Matrix *)jarg1;
16931   if (!arg1) {
16932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16933     return 0;
16934   }
16935   {
16936     try {
16937       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16938     } catch (std::out_of_range& e) {
16939       {
16940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16941       };
16942     } catch (std::exception& e) {
16943       {
16944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16945       };
16946     } catch (Dali::DaliException e) {
16947       {
16948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16949       };
16950     } catch (...) {
16951       {
16952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16953       };
16954     }
16955   }
16956
16957   jresult = (void *)result;
16958   return jresult;
16959 }
16960
16961
16962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16963   void * jresult ;
16964   Dali::Rect< int > *arg1 = 0 ;
16965   Dali::Property::Value *result = 0 ;
16966
16967   arg1 = (Dali::Rect< int > *)jarg1;
16968   if (!arg1) {
16969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16970     return 0;
16971   }
16972   {
16973     try {
16974       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16975     } catch (std::out_of_range& e) {
16976       {
16977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16978       };
16979     } catch (std::exception& e) {
16980       {
16981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16982       };
16983     } catch (Dali::DaliException e) {
16984       {
16985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16986       };
16987     } catch (...) {
16988       {
16989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16990       };
16991     }
16992   }
16993
16994   jresult = (void *)result;
16995   return jresult;
16996 }
16997
16998
16999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17000   void * jresult ;
17001   Dali::AngleAxis *arg1 = 0 ;
17002   Dali::Property::Value *result = 0 ;
17003
17004   arg1 = (Dali::AngleAxis *)jarg1;
17005   if (!arg1) {
17006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17007     return 0;
17008   }
17009   {
17010     try {
17011       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17012     } catch (std::out_of_range& e) {
17013       {
17014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17015       };
17016     } catch (std::exception& e) {
17017       {
17018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17019       };
17020     } catch (Dali::DaliException e) {
17021       {
17022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17023       };
17024     } catch (...) {
17025       {
17026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17027       };
17028     }
17029   }
17030
17031   jresult = (void *)result;
17032   return jresult;
17033 }
17034
17035
17036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17037   void * jresult ;
17038   Dali::Quaternion *arg1 = 0 ;
17039   Dali::Property::Value *result = 0 ;
17040
17041   arg1 = (Dali::Quaternion *)jarg1;
17042   if (!arg1) {
17043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17044     return 0;
17045   }
17046   {
17047     try {
17048       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17049     } catch (std::out_of_range& e) {
17050       {
17051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17052       };
17053     } catch (std::exception& e) {
17054       {
17055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17056       };
17057     } catch (Dali::DaliException e) {
17058       {
17059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17060       };
17061     } catch (...) {
17062       {
17063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17064       };
17065     }
17066   }
17067
17068   jresult = (void *)result;
17069   return jresult;
17070 }
17071
17072
17073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17074   void * jresult ;
17075   std::string *arg1 = 0 ;
17076   Dali::Property::Value *result = 0 ;
17077
17078   if (!jarg1) {
17079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17080     return 0;
17081   }
17082   std::string arg1_str(jarg1);
17083   arg1 = &arg1_str;
17084   {
17085     try {
17086       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17087     } catch (std::out_of_range& e) {
17088       {
17089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17090       };
17091     } catch (std::exception& e) {
17092       {
17093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17094       };
17095     } catch (Dali::DaliException e) {
17096       {
17097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17098       };
17099     } catch (...) {
17100       {
17101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17102       };
17103     }
17104   }
17105
17106   jresult = (void *)result;
17107
17108   //argout typemap for const std::string&
17109
17110   return jresult;
17111 }
17112
17113
17114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17115   void * jresult ;
17116   Dali::Property::Array *arg1 = 0 ;
17117   Dali::Property::Value *result = 0 ;
17118
17119   arg1 = (Dali::Property::Array *)jarg1;
17120   if (!arg1) {
17121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17122     return 0;
17123   }
17124   {
17125     try {
17126       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17127     } catch (std::out_of_range& e) {
17128       {
17129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17130       };
17131     } catch (std::exception& e) {
17132       {
17133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17134       };
17135     } catch (Dali::DaliException e) {
17136       {
17137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17138       };
17139     } catch (...) {
17140       {
17141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17142       };
17143     }
17144   }
17145
17146   jresult = (void *)result;
17147   return jresult;
17148 }
17149
17150
17151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17152   void * jresult ;
17153   Dali::Property::Map *arg1 = 0 ;
17154   Dali::Property::Value *result = 0 ;
17155
17156   arg1 = (Dali::Property::Map *)jarg1;
17157   if (!arg1) {
17158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17159     return 0;
17160   }
17161   {
17162     try {
17163       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17164     } catch (std::out_of_range& e) {
17165       {
17166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17167       };
17168     } catch (std::exception& e) {
17169       {
17170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17171       };
17172     } catch (Dali::DaliException e) {
17173       {
17174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17175       };
17176     } catch (...) {
17177       {
17178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17179       };
17180     }
17181   }
17182
17183   jresult = (void *)result;
17184   return jresult;
17185 }
17186
17187
17188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17189   void * jresult ;
17190   Extents *arg1 = 0 ;
17191   Dali::Property::Value *result = 0 ;
17192
17193   arg1 = (Extents *)jarg1;
17194   if (!arg1) {
17195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17196     return 0;
17197   }
17198   {
17199     try {
17200       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17201     } catch (std::out_of_range& e) {
17202       {
17203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17204       };
17205     } catch (std::exception& e) {
17206       {
17207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17208       };
17209     } catch (...) {
17210       {
17211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17212       };
17213     }
17214   }
17215   jresult = (void *)result;
17216   return jresult;
17217 }
17218
17219
17220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17221   void * jresult ;
17222   Dali::Property::Type arg1 ;
17223   Dali::Property::Value *result = 0 ;
17224
17225   arg1 = (Dali::Property::Type)jarg1;
17226   {
17227     try {
17228       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17229     } catch (std::out_of_range& e) {
17230       {
17231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17232       };
17233     } catch (std::exception& e) {
17234       {
17235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17236       };
17237     } catch (Dali::DaliException e) {
17238       {
17239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17240       };
17241     } catch (...) {
17242       {
17243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17244       };
17245     }
17246   }
17247
17248   jresult = (void *)result;
17249   return jresult;
17250 }
17251
17252
17253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17254   void * jresult ;
17255   Dali::Property::Value *arg1 = 0 ;
17256   Dali::Property::Value *result = 0 ;
17257
17258   arg1 = (Dali::Property::Value *)jarg1;
17259   if (!arg1) {
17260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17261     return 0;
17262   }
17263   {
17264     try {
17265       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17266     } catch (std::out_of_range& e) {
17267       {
17268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17269       };
17270     } catch (std::exception& e) {
17271       {
17272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17273       };
17274     } catch (Dali::DaliException e) {
17275       {
17276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17277       };
17278     } catch (...) {
17279       {
17280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17281       };
17282     }
17283   }
17284
17285   jresult = (void *)result;
17286   return jresult;
17287 }
17288
17289
17290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17291   void * jresult ;
17292   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17293   Dali::Property::Value *arg2 = 0 ;
17294   Dali::Property::Value *result = 0 ;
17295
17296   arg1 = (Dali::Property::Value *)jarg1;
17297   arg2 = (Dali::Property::Value *)jarg2;
17298   if (!arg2) {
17299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17300     return 0;
17301   }
17302   {
17303     try {
17304       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17305     } catch (std::out_of_range& e) {
17306       {
17307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17308       };
17309     } catch (std::exception& e) {
17310       {
17311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17312       };
17313     } catch (Dali::DaliException e) {
17314       {
17315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17316       };
17317     } catch (...) {
17318       {
17319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17320       };
17321     }
17322   }
17323
17324   jresult = (void *)result;
17325   return jresult;
17326 }
17327
17328
17329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17330   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17331
17332   arg1 = (Dali::Property::Value *)jarg1;
17333   {
17334     try {
17335       delete arg1;
17336     } catch (std::out_of_range& e) {
17337       {
17338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17339       };
17340     } catch (std::exception& e) {
17341       {
17342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17343       };
17344     } catch (Dali::DaliException e) {
17345       {
17346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17347       };
17348     } catch (...) {
17349       {
17350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17351       };
17352     }
17353   }
17354
17355 }
17356
17357
17358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17359   int jresult ;
17360   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17361   Dali::Property::Type result;
17362
17363   arg1 = (Dali::Property::Value *)jarg1;
17364   {
17365     try {
17366       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17367     } catch (std::out_of_range& e) {
17368       {
17369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17370       };
17371     } catch (std::exception& e) {
17372       {
17373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17374       };
17375     } catch (Dali::DaliException e) {
17376       {
17377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17378       };
17379     } catch (...) {
17380       {
17381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17382       };
17383     }
17384   }
17385
17386   jresult = (int)result;
17387   return jresult;
17388 }
17389
17390
17391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17392   unsigned int jresult ;
17393   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17394   bool *arg2 = 0 ;
17395   bool result;
17396
17397   arg1 = (Dali::Property::Value *)jarg1;
17398   arg2 = (bool *)jarg2;
17399   {
17400     try {
17401       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17402     } catch (std::out_of_range& e) {
17403       {
17404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17405       };
17406     } catch (std::exception& e) {
17407       {
17408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17409       };
17410     } catch (Dali::DaliException e) {
17411       {
17412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17413       };
17414     } catch (...) {
17415       {
17416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17417       };
17418     }
17419   }
17420
17421   jresult = result;
17422   return jresult;
17423 }
17424
17425
17426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17427   unsigned int jresult ;
17428   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17429   float *arg2 = 0 ;
17430   bool result;
17431
17432   arg1 = (Dali::Property::Value *)jarg1;
17433   arg2 = (float *)jarg2;
17434   {
17435     try {
17436       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17437     } catch (std::out_of_range& e) {
17438       {
17439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17440       };
17441     } catch (std::exception& e) {
17442       {
17443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17444       };
17445     } catch (Dali::DaliException e) {
17446       {
17447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17448       };
17449     } catch (...) {
17450       {
17451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17452       };
17453     }
17454   }
17455
17456   jresult = result;
17457   return jresult;
17458 }
17459
17460
17461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17462   unsigned int jresult ;
17463   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17464   int *arg2 = 0 ;
17465   bool result;
17466
17467   arg1 = (Dali::Property::Value *)jarg1;
17468   arg2 = (int *)jarg2;
17469   {
17470     try {
17471       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17472     } catch (std::out_of_range& e) {
17473       {
17474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17475       };
17476     } catch (std::exception& e) {
17477       {
17478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17479       };
17480     } catch (Dali::DaliException e) {
17481       {
17482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17483       };
17484     } catch (...) {
17485       {
17486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17487       };
17488     }
17489   }
17490
17491   jresult = result;
17492   return jresult;
17493 }
17494
17495
17496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17497   unsigned int jresult ;
17498   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17499   Dali::Rect< int > *arg2 = 0 ;
17500   bool result;
17501
17502   arg1 = (Dali::Property::Value *)jarg1;
17503   arg2 = (Dali::Rect< int > *)jarg2;
17504   if (!arg2) {
17505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17506     return 0;
17507   }
17508   {
17509     try {
17510       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17511     } catch (std::out_of_range& e) {
17512       {
17513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17514       };
17515     } catch (std::exception& e) {
17516       {
17517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17518       };
17519     } catch (Dali::DaliException e) {
17520       {
17521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17522       };
17523     } catch (...) {
17524       {
17525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17526       };
17527     }
17528   }
17529
17530   jresult = result;
17531   return jresult;
17532 }
17533
17534
17535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17536   unsigned int jresult ;
17537   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17538   Dali::Vector2 *arg2 = 0 ;
17539   bool result;
17540
17541   arg1 = (Dali::Property::Value *)jarg1;
17542   arg2 = (Dali::Vector2 *)jarg2;
17543   if (!arg2) {
17544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17545     return 0;
17546   }
17547   {
17548     try {
17549       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17550     } catch (std::out_of_range& e) {
17551       {
17552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17553       };
17554     } catch (std::exception& e) {
17555       {
17556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17557       };
17558     } catch (Dali::DaliException e) {
17559       {
17560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17561       };
17562     } catch (...) {
17563       {
17564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17565       };
17566     }
17567   }
17568
17569   jresult = result;
17570   return jresult;
17571 }
17572
17573
17574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17575   unsigned int jresult ;
17576   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17577   Dali::Vector3 *arg2 = 0 ;
17578   bool result;
17579
17580   arg1 = (Dali::Property::Value *)jarg1;
17581   arg2 = (Dali::Vector3 *)jarg2;
17582   if (!arg2) {
17583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17584     return 0;
17585   }
17586   {
17587     try {
17588       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17589     } catch (std::out_of_range& e) {
17590       {
17591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17592       };
17593     } catch (std::exception& e) {
17594       {
17595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17596       };
17597     } catch (Dali::DaliException e) {
17598       {
17599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17600       };
17601     } catch (...) {
17602       {
17603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17604       };
17605     }
17606   }
17607
17608   jresult = result;
17609   return jresult;
17610 }
17611
17612
17613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17614   unsigned int jresult ;
17615   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17616   Dali::Vector4 *arg2 = 0 ;
17617   bool result;
17618
17619   arg1 = (Dali::Property::Value *)jarg1;
17620   arg2 = (Dali::Vector4 *)jarg2;
17621   if (!arg2) {
17622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17623     return 0;
17624   }
17625   {
17626     try {
17627       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17628     } catch (std::out_of_range& e) {
17629       {
17630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17631       };
17632     } catch (std::exception& e) {
17633       {
17634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17635       };
17636     } catch (Dali::DaliException e) {
17637       {
17638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17639       };
17640     } catch (...) {
17641       {
17642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17643       };
17644     }
17645   }
17646
17647   jresult = result;
17648   return jresult;
17649 }
17650
17651
17652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17653   unsigned int jresult ;
17654   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17655   Dali::Matrix3 *arg2 = 0 ;
17656   bool result;
17657
17658   arg1 = (Dali::Property::Value *)jarg1;
17659   arg2 = (Dali::Matrix3 *)jarg2;
17660   if (!arg2) {
17661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17662     return 0;
17663   }
17664   {
17665     try {
17666       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17667     } catch (std::out_of_range& e) {
17668       {
17669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17670       };
17671     } catch (std::exception& e) {
17672       {
17673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17674       };
17675     } catch (Dali::DaliException e) {
17676       {
17677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17678       };
17679     } catch (...) {
17680       {
17681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17682       };
17683     }
17684   }
17685
17686   jresult = result;
17687   return jresult;
17688 }
17689
17690
17691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17692   unsigned int jresult ;
17693   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17694   Dali::Matrix *arg2 = 0 ;
17695   bool result;
17696
17697   arg1 = (Dali::Property::Value *)jarg1;
17698   arg2 = (Dali::Matrix *)jarg2;
17699   if (!arg2) {
17700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17701     return 0;
17702   }
17703   {
17704     try {
17705       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17706     } catch (std::out_of_range& e) {
17707       {
17708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17709       };
17710     } catch (std::exception& e) {
17711       {
17712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17713       };
17714     } catch (Dali::DaliException e) {
17715       {
17716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17717       };
17718     } catch (...) {
17719       {
17720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17721       };
17722     }
17723   }
17724
17725   jresult = result;
17726   return jresult;
17727 }
17728
17729
17730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17731   unsigned int jresult ;
17732   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17733   Dali::AngleAxis *arg2 = 0 ;
17734   bool result;
17735
17736   arg1 = (Dali::Property::Value *)jarg1;
17737   arg2 = (Dali::AngleAxis *)jarg2;
17738   if (!arg2) {
17739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17740     return 0;
17741   }
17742   {
17743     try {
17744       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17745     } catch (std::out_of_range& e) {
17746       {
17747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17748       };
17749     } catch (std::exception& e) {
17750       {
17751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17752       };
17753     } catch (Dali::DaliException e) {
17754       {
17755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17756       };
17757     } catch (...) {
17758       {
17759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17760       };
17761     }
17762   }
17763
17764   jresult = result;
17765   return jresult;
17766 }
17767
17768
17769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17770   unsigned int jresult ;
17771   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17772   Dali::Quaternion *arg2 = 0 ;
17773   bool result;
17774
17775   arg1 = (Dali::Property::Value *)jarg1;
17776   arg2 = (Dali::Quaternion *)jarg2;
17777   if (!arg2) {
17778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17779     return 0;
17780   }
17781   {
17782     try {
17783       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17784     } catch (std::out_of_range& e) {
17785       {
17786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17787       };
17788     } catch (std::exception& e) {
17789       {
17790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17791       };
17792     } catch (Dali::DaliException e) {
17793       {
17794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17795       };
17796     } catch (...) {
17797       {
17798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17799       };
17800     }
17801   }
17802
17803   jresult = result;
17804   return jresult;
17805 }
17806
17807
17808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17809   unsigned int jresult ;
17810   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17811   std::string *arg2 = 0 ;
17812   bool result;
17813
17814   arg1 = (Dali::Property::Value *)jarg1;
17815
17816   //typemap in
17817   std::string temp;
17818   arg2 = &temp;
17819
17820   {
17821     try {
17822       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17823     } catch (std::out_of_range& e) {
17824       {
17825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17826       };
17827     } catch (std::exception& e) {
17828       {
17829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17830       };
17831     } catch (Dali::DaliException e) {
17832       {
17833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17834       };
17835     } catch (...) {
17836       {
17837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17838       };
17839     }
17840   }
17841
17842   jresult = result;
17843
17844   //Typemap argout in c++ file.
17845   //This will convert c++ string to c# string
17846   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17847
17848   return jresult;
17849 }
17850
17851
17852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17853   unsigned int jresult ;
17854   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17855   Dali::Property::Array *arg2 = 0 ;
17856   bool result;
17857
17858   arg1 = (Dali::Property::Value *)jarg1;
17859   arg2 = (Dali::Property::Array *)jarg2;
17860   if (!arg2) {
17861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17862     return 0;
17863   }
17864   {
17865     try {
17866       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17867     } catch (std::out_of_range& e) {
17868       {
17869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17870       };
17871     } catch (std::exception& e) {
17872       {
17873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17874       };
17875     } catch (Dali::DaliException e) {
17876       {
17877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17878       };
17879     } catch (...) {
17880       {
17881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17882       };
17883     }
17884   }
17885
17886   jresult = result;
17887   return jresult;
17888 }
17889
17890
17891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17892   unsigned int jresult ;
17893   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17894   Dali::Property::Map *arg2 = 0 ;
17895   bool result;
17896
17897   arg1 = (Dali::Property::Value *)jarg1;
17898   arg2 = (Dali::Property::Map *)jarg2;
17899   if (!arg2) {
17900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17901     return 0;
17902   }
17903   {
17904     try {
17905       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17906     } catch (std::out_of_range& e) {
17907       {
17908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17909       };
17910     } catch (std::exception& e) {
17911       {
17912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17913       };
17914     } catch (Dali::DaliException e) {
17915       {
17916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17917       };
17918     } catch (...) {
17919       {
17920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17921       };
17922     }
17923   }
17924
17925   jresult = result;
17926   return jresult;
17927 }
17928
17929
17930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17931   unsigned int jresult ;
17932   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17933   Extents *arg2 = 0 ;
17934   bool result;
17935
17936   arg1 = (Dali::Property::Value *)jarg1;
17937   arg2 = (Extents *)jarg2;
17938   if (!arg2) {
17939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17940     return 0;
17941   }
17942   {
17943     try {
17944       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17945     } catch (std::out_of_range& e) {
17946       {
17947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17948       };
17949     } catch (std::exception& e) {
17950       {
17951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17952       };
17953     } catch (...) {
17954       {
17955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17956       };
17957     }
17958   }
17959   jresult = result;
17960   return jresult;
17961 }
17962
17963
17964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17965   void * jresult ;
17966   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17967   Dali::Property::Array *result = 0 ;
17968
17969   arg1 = (Dali::Property::Value *)jarg1;
17970   {
17971     try {
17972       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17973     } catch (std::out_of_range& e) {
17974       {
17975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17976       };
17977     } catch (std::exception& e) {
17978       {
17979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17980       };
17981     } catch (Dali::DaliException e) {
17982       {
17983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17984       };
17985     } catch (...) {
17986       {
17987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17988       };
17989     }
17990   }
17991
17992   jresult = (void *)result;
17993   return jresult;
17994 }
17995
17996
17997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17998   void * jresult ;
17999   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18000   Dali::Property::Map *result = 0 ;
18001
18002   arg1 = (Dali::Property::Value *)jarg1;
18003   {
18004     try {
18005       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18006     } catch (std::out_of_range& e) {
18007       {
18008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18009       };
18010     } catch (std::exception& e) {
18011       {
18012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18013       };
18014     } catch (Dali::DaliException e) {
18015       {
18016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18017       };
18018     } catch (...) {
18019       {
18020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18021       };
18022     }
18023   }
18024
18025   jresult = (void *)result;
18026   return jresult;
18027 }
18028
18029
18030 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18031   char * jresult ;
18032   Dali::Property::Type arg1 ;
18033   char *result = 0 ;
18034
18035   arg1 = (Dali::Property::Type)jarg1;
18036   {
18037     try {
18038       result = (char *)Dali::PropertyTypes::GetName(arg1);
18039     } catch (std::out_of_range& e) {
18040       {
18041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18042       };
18043     } catch (std::exception& e) {
18044       {
18045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18046       };
18047     } catch (Dali::DaliException e) {
18048       {
18049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18050       };
18051     } catch (...) {
18052       {
18053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18054       };
18055     }
18056   }
18057
18058   jresult = SWIG_csharp_string_callback((const char *)result);
18059   return jresult;
18060 }
18061
18062
18063 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18064   unsigned int jresult ;
18065   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18066   std::string *arg2 = 0 ;
18067   Dali::Property::Map *arg3 = 0 ;
18068   bool result;
18069
18070   arg1 = (Dali::BaseObject *)jarg1;
18071   if (!jarg2) {
18072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18073     return 0;
18074   }
18075   std::string arg2_str(jarg2);
18076   arg2 = &arg2_str;
18077   arg3 = (Dali::Property::Map *)jarg3;
18078   if (!arg3) {
18079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18080     return 0;
18081   }
18082   {
18083     try {
18084       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18085     } catch (std::out_of_range& e) {
18086       {
18087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18088       };
18089     } catch (std::exception& e) {
18090       {
18091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18092       };
18093     } catch (Dali::DaliException e) {
18094       {
18095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18096       };
18097     } catch (...) {
18098       {
18099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18100       };
18101     }
18102   }
18103
18104   jresult = result;
18105
18106   //argout typemap for const std::string&
18107
18108   return jresult;
18109 }
18110
18111
18112 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18113   char * jresult ;
18114   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18115   std::string *result = 0 ;
18116
18117   arg1 = (Dali::BaseObject *)jarg1;
18118   {
18119     try {
18120       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18121     } catch (std::out_of_range& e) {
18122       {
18123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18124       };
18125     } catch (std::exception& e) {
18126       {
18127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18128       };
18129     } catch (Dali::DaliException e) {
18130       {
18131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18132       };
18133     } catch (...) {
18134       {
18135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18136       };
18137     }
18138   }
18139
18140   jresult = SWIG_csharp_string_callback(result->c_str());
18141   return jresult;
18142 }
18143
18144
18145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18146   unsigned int jresult ;
18147   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18148   Dali::TypeInfo *arg2 = 0 ;
18149   bool result;
18150
18151   arg1 = (Dali::BaseObject *)jarg1;
18152   arg2 = (Dali::TypeInfo *)jarg2;
18153   if (!arg2) {
18154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18155     return 0;
18156   }
18157   {
18158     try {
18159       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18160     } catch (std::out_of_range& e) {
18161       {
18162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18163       };
18164     } catch (std::exception& e) {
18165       {
18166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18167       };
18168     } catch (Dali::DaliException e) {
18169       {
18170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18171       };
18172     } catch (...) {
18173       {
18174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18175       };
18176     }
18177   }
18178
18179   jresult = result;
18180   return jresult;
18181 }
18182
18183
18184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18185   unsigned int jresult ;
18186   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18187   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18188   std::string *arg3 = 0 ;
18189   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18190   bool result;
18191
18192   arg1 = (Dali::BaseObject *)jarg1;
18193   arg2 = (ConnectionTrackerInterface *)jarg2;
18194   if (!jarg3) {
18195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18196     return 0;
18197   }
18198   std::string arg3_str(jarg3);
18199   arg3 = &arg3_str;
18200   arg4 = (FunctorDelegate *)jarg4;
18201   {
18202     try {
18203       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18204     } catch (std::out_of_range& e) {
18205       {
18206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18207       };
18208     } catch (std::exception& e) {
18209       {
18210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18211       };
18212     } catch (Dali::DaliException e) {
18213       {
18214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18215       };
18216     } catch (...) {
18217       {
18218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18219       };
18220     }
18221   }
18222
18223   jresult = result;
18224
18225   //argout typemap for const std::string&
18226
18227   return jresult;
18228 }
18229
18230
18231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18232   void * jresult ;
18233   Dali::BaseHandle *arg1 = 0 ;
18234   Dali::BaseObject *result = 0 ;
18235
18236   arg1 = (Dali::BaseHandle *)jarg1;
18237   if (!arg1) {
18238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18239     return 0;
18240   }
18241   {
18242     try {
18243       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18244     } catch (std::out_of_range& e) {
18245       {
18246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18247       };
18248     } catch (std::exception& e) {
18249       {
18250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18251       };
18252     } catch (Dali::DaliException e) {
18253       {
18254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18255       };
18256     } catch (...) {
18257       {
18258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18259       };
18260     }
18261   }
18262
18263   jresult = (void *)result;
18264   return jresult;
18265 }
18266
18267
18268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18269   void * jresult ;
18270   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18271   Dali::BaseHandle *result = 0 ;
18272
18273   arg1 = (Dali::BaseObject *)jarg1;
18274   {
18275     try {
18276       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18277     } catch (std::out_of_range& e) {
18278       {
18279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18280       };
18281     } catch (std::exception& e) {
18282       {
18283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18284       };
18285     } catch (Dali::DaliException e) {
18286       {
18287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18288       };
18289     } catch (...) {
18290       {
18291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18292       };
18293     }
18294   }
18295
18296   jresult = (void *)result;
18297   return jresult;
18298 }
18299
18300
18301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18302   void * jresult ;
18303   Dali::BaseHandle *result = 0 ;
18304
18305   {
18306     try {
18307       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18308     } catch (std::out_of_range& e) {
18309       {
18310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18311       };
18312     } catch (std::exception& e) {
18313       {
18314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18315       };
18316     } catch (Dali::DaliException e) {
18317       {
18318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18319       };
18320     } catch (...) {
18321       {
18322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18323       };
18324     }
18325   }
18326
18327   jresult = (void *)result;
18328   return jresult;
18329 }
18330
18331
18332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18333   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18334
18335   arg1 = (Dali::BaseHandle *)jarg1;
18336   {
18337     try {
18338       delete arg1;
18339     } catch (std::out_of_range& e) {
18340       {
18341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18342       };
18343     } catch (std::exception& e) {
18344       {
18345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18346       };
18347     } catch (Dali::DaliException e) {
18348       {
18349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18350       };
18351     } catch (...) {
18352       {
18353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18354       };
18355     }
18356   }
18357
18358 }
18359
18360
18361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18362   void * jresult ;
18363   Dali::BaseHandle *arg1 = 0 ;
18364   Dali::BaseHandle *result = 0 ;
18365
18366   arg1 = (Dali::BaseHandle *)jarg1;
18367   if (!arg1) {
18368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18369     return 0;
18370   }
18371   {
18372     try {
18373       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18374     } catch (std::out_of_range& e) {
18375       {
18376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18377       };
18378     } catch (std::exception& e) {
18379       {
18380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18381       };
18382     } catch (Dali::DaliException e) {
18383       {
18384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18385       };
18386     } catch (...) {
18387       {
18388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18389       };
18390     }
18391   }
18392
18393   jresult = (void *)result;
18394   return jresult;
18395 }
18396
18397
18398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18399   void * jresult ;
18400   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18401   Dali::BaseHandle *arg2 = 0 ;
18402   Dali::BaseHandle *result = 0 ;
18403
18404   arg1 = (Dali::BaseHandle *)jarg1;
18405   arg2 = (Dali::BaseHandle *)jarg2;
18406   if (!arg2) {
18407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18408     return 0;
18409   }
18410   {
18411     try {
18412       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18413     } catch (std::out_of_range& e) {
18414       {
18415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18416       };
18417     } catch (std::exception& e) {
18418       {
18419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18420       };
18421     } catch (Dali::DaliException e) {
18422       {
18423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18424       };
18425     } catch (...) {
18426       {
18427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18428       };
18429     }
18430   }
18431
18432   jresult = (void *)result;
18433   return jresult;
18434 }
18435
18436
18437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18438   unsigned int jresult ;
18439   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18440   std::string *arg2 = 0 ;
18441   Dali::Property::Map *arg3 = 0 ;
18442   bool result;
18443
18444   arg1 = (Dali::BaseHandle *)jarg1;
18445   if (!jarg2) {
18446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18447     return 0;
18448   }
18449   std::string arg2_str(jarg2);
18450   arg2 = &arg2_str;
18451   arg3 = (Dali::Property::Map *)jarg3;
18452   if (!arg3) {
18453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18454     return 0;
18455   }
18456   {
18457     try {
18458       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18459     } catch (std::out_of_range& e) {
18460       {
18461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18462       };
18463     } catch (std::exception& e) {
18464       {
18465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18466       };
18467     } catch (Dali::DaliException e) {
18468       {
18469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18470       };
18471     } catch (...) {
18472       {
18473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18474       };
18475     }
18476   }
18477
18478   jresult = result;
18479
18480   //argout typemap for const std::string&
18481
18482   return jresult;
18483 }
18484
18485
18486 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18487   char * jresult ;
18488   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18489   std::string *result = 0 ;
18490
18491   arg1 = (Dali::BaseHandle *)jarg1;
18492   {
18493     try {
18494       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18495     } catch (std::out_of_range& e) {
18496       {
18497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18498       };
18499     } catch (std::exception& e) {
18500       {
18501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18502       };
18503     } catch (Dali::DaliException e) {
18504       {
18505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18506       };
18507     } catch (...) {
18508       {
18509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18510       };
18511     }
18512   }
18513
18514   jresult = SWIG_csharp_string_callback(result->c_str());
18515   return jresult;
18516 }
18517
18518
18519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18520   unsigned int jresult ;
18521   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18522   Dali::TypeInfo *arg2 = 0 ;
18523   bool result;
18524
18525   arg1 = (Dali::BaseHandle *)jarg1;
18526   arg2 = (Dali::TypeInfo *)jarg2;
18527   if (!arg2) {
18528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18529     return 0;
18530   }
18531   {
18532     try {
18533       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18534     } catch (std::out_of_range& e) {
18535       {
18536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18537       };
18538     } catch (std::exception& e) {
18539       {
18540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18541       };
18542     } catch (Dali::DaliException e) {
18543       {
18544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18545       };
18546     } catch (...) {
18547       {
18548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18549       };
18550     }
18551   }
18552
18553   jresult = result;
18554   return jresult;
18555 }
18556
18557
18558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18559   void * jresult ;
18560   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18561   Dali::BaseObject *result = 0 ;
18562
18563   arg1 = (Dali::BaseHandle *)jarg1;
18564   {
18565     try {
18566       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18567     } catch (std::out_of_range& e) {
18568       {
18569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18570       };
18571     } catch (std::exception& e) {
18572       {
18573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18574       };
18575     } catch (Dali::DaliException e) {
18576       {
18577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18578       };
18579     } catch (...) {
18580       {
18581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18582       };
18583     }
18584   }
18585
18586   jresult = (void *)result;
18587   return jresult;
18588 }
18589
18590
18591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18592   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18593
18594   arg1 = (Dali::BaseHandle *)jarg1;
18595   {
18596     try {
18597       (arg1)->Reset();
18598     } catch (std::out_of_range& e) {
18599       {
18600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18601       };
18602     } catch (std::exception& e) {
18603       {
18604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18605       };
18606     } catch (Dali::DaliException e) {
18607       {
18608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18609       };
18610     } catch (...) {
18611       {
18612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18613       };
18614     }
18615   }
18616
18617 }
18618
18619
18620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18621   unsigned int jresult ;
18622   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18623   Dali::BaseHandle *arg2 = 0 ;
18624   bool result;
18625
18626   arg1 = (Dali::BaseHandle *)jarg1;
18627   arg2 = (Dali::BaseHandle *)jarg2;
18628   if (!arg2) {
18629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18630     return 0;
18631   }
18632   {
18633     try {
18634       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18635     } catch (std::out_of_range& e) {
18636       {
18637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18638       };
18639     } catch (std::exception& e) {
18640       {
18641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18642       };
18643     } catch (Dali::DaliException e) {
18644       {
18645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18646       };
18647     } catch (...) {
18648       {
18649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18650       };
18651     }
18652   }
18653
18654   jresult = result;
18655   return jresult;
18656 }
18657
18658
18659 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18660   unsigned int jresult ;
18661   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18662   Dali::BaseHandle *arg2 = 0 ;
18663   bool result;
18664
18665   arg1 = (Dali::BaseHandle *)jarg1;
18666   arg2 = (Dali::BaseHandle *)jarg2;
18667   if (!arg2) {
18668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18669     return 0;
18670   }
18671   {
18672     try {
18673       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18674     } catch (std::out_of_range& e) {
18675       {
18676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18677       };
18678     } catch (std::exception& e) {
18679       {
18680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18681       };
18682     } catch (Dali::DaliException e) {
18683       {
18684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18685       };
18686     } catch (...) {
18687       {
18688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18689       };
18690     }
18691   }
18692
18693   jresult = result;
18694   return jresult;
18695 }
18696
18697
18698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18699   void * jresult ;
18700   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18701   Dali::RefObject *result = 0 ;
18702
18703   arg1 = (Dali::BaseHandle *)jarg1;
18704   {
18705     try {
18706       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18707     } catch (std::out_of_range& e) {
18708       {
18709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18710       };
18711     } catch (std::exception& e) {
18712       {
18713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18714       };
18715     } catch (Dali::DaliException e) {
18716       {
18717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18718       };
18719     } catch (...) {
18720       {
18721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18722       };
18723     }
18724   }
18725
18726   jresult = (void *)result;
18727   return jresult;
18728 }
18729
18730
18731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18732   unsigned int jresult ;
18733   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18734   bool result;
18735
18736   arg1 = (Dali::BaseHandle *)jarg1;
18737   {
18738     try {
18739       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18740     } catch (std::out_of_range& e) {
18741       {
18742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18743       };
18744     } catch (std::exception& e) {
18745       {
18746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18747       };
18748     } catch (Dali::DaliException e) {
18749       {
18750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18751       };
18752     } catch (...) {
18753       {
18754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18755       };
18756     }
18757   }
18758
18759   jresult = result;
18760   return jresult;
18761 }
18762
18763
18764 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18765   unsigned int jresult ;
18766   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18767   Dali::BaseHandle *arg2 = 0 ;
18768   bool result;
18769
18770   arg1 = (Dali::BaseHandle *)jarg1;
18771   arg2 = (Dali::BaseHandle *)jarg2;
18772   if (!arg2) {
18773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18774     return 0;
18775   }
18776   {
18777     try {
18778       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18779     } catch (std::out_of_range& e) {
18780       {
18781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18782       };
18783     } catch (std::exception& e) {
18784       {
18785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18786       };
18787     } catch (Dali::DaliException e) {
18788       {
18789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18790       };
18791     } catch (...) {
18792       {
18793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18794       };
18795     }
18796   }
18797
18798   jresult = result;
18799   return jresult;
18800 }
18801
18802
18803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18804   unsigned int jresult ;
18805   Dali::BaseHandle *arg1 = 0 ;
18806   Dali::BaseHandle *arg2 = 0 ;
18807   bool result;
18808
18809   arg1 = (Dali::BaseHandle *)jarg1;
18810   if (!arg1) {
18811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18812     return 0;
18813   }
18814   arg2 = (Dali::BaseHandle *)jarg2;
18815   if (!arg2) {
18816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18817     return 0;
18818   }
18819   {
18820     try {
18821       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18822     } catch (std::out_of_range& e) {
18823       {
18824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18825       };
18826     } catch (std::exception& e) {
18827       {
18828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18829       };
18830     } catch (Dali::DaliException e) {
18831       {
18832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18833       };
18834     } catch (...) {
18835       {
18836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18837       };
18838     }
18839   }
18840
18841   jresult = result;
18842   return jresult;
18843 }
18844
18845
18846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18847   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18848
18849   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18850   {
18851     try {
18852       delete arg1;
18853     } catch (std::out_of_range& e) {
18854       {
18855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18856       };
18857     } catch (std::exception& e) {
18858       {
18859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18860       };
18861     } catch (Dali::DaliException e) {
18862       {
18863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18864       };
18865     } catch (...) {
18866       {
18867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18868       };
18869     }
18870   }
18871
18872 }
18873
18874
18875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18876   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18877   SlotObserver *arg2 = (SlotObserver *) 0 ;
18878   CallbackBase *arg3 = (CallbackBase *) 0 ;
18879
18880   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18881   arg2 = (SlotObserver *)jarg2;
18882   arg3 = (CallbackBase *)jarg3;
18883   {
18884     try {
18885       (arg1)->SignalConnected(arg2,arg3);
18886     } catch (std::out_of_range& e) {
18887       {
18888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18889       };
18890     } catch (std::exception& e) {
18891       {
18892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18893       };
18894     } catch (Dali::DaliException e) {
18895       {
18896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18897       };
18898     } catch (...) {
18899       {
18900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18901       };
18902     }
18903   }
18904
18905 }
18906
18907
18908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18909   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18910
18911   arg1 = (Dali::SignalObserver *)jarg1;
18912   {
18913     try {
18914       delete arg1;
18915     } catch (std::out_of_range& e) {
18916       {
18917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18918       };
18919     } catch (std::exception& e) {
18920       {
18921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18922       };
18923     } catch (Dali::DaliException e) {
18924       {
18925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18926       };
18927     } catch (...) {
18928       {
18929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18930       };
18931     }
18932   }
18933
18934 }
18935
18936
18937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18938   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18939   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18940   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18941
18942   arg1 = (Dali::SignalObserver *)jarg1;
18943   arg2 = (Dali::SlotObserver *)jarg2;
18944   arg3 = (Dali::CallbackBase *)jarg3;
18945   {
18946     try {
18947       (arg1)->SignalDisconnected(arg2,arg3);
18948     } catch (std::out_of_range& e) {
18949       {
18950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18951       };
18952     } catch (std::exception& e) {
18953       {
18954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18955       };
18956     } catch (Dali::DaliException e) {
18957       {
18958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18959       };
18960     } catch (...) {
18961       {
18962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18963       };
18964     }
18965   }
18966
18967 }
18968
18969
18970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18971   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18972
18973   arg1 = (Dali::SlotObserver *)jarg1;
18974   {
18975     try {
18976       delete arg1;
18977     } catch (std::out_of_range& e) {
18978       {
18979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18980       };
18981     } catch (std::exception& e) {
18982       {
18983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18984       };
18985     } catch (Dali::DaliException e) {
18986       {
18987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18988       };
18989     } catch (...) {
18990       {
18991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18992       };
18993     }
18994   }
18995
18996 }
18997
18998
18999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19000   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19001   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19002
19003   arg1 = (Dali::SlotObserver *)jarg1;
19004   arg2 = (Dali::CallbackBase *)jarg2;
19005   {
19006     try {
19007       (arg1)->SlotDisconnected(arg2);
19008     } catch (std::out_of_range& e) {
19009       {
19010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19011       };
19012     } catch (std::exception& e) {
19013       {
19014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19015       };
19016     } catch (Dali::DaliException e) {
19017       {
19018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19019       };
19020     } catch (...) {
19021       {
19022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19023       };
19024     }
19025   }
19026
19027 }
19028
19029
19030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19031   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19032
19033   arg1 = (Dali::ConnectionTracker *)jarg1;
19034   {
19035     try {
19036       delete arg1;
19037     } catch (std::out_of_range& e) {
19038       {
19039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19040       };
19041     } catch (std::exception& e) {
19042       {
19043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19044       };
19045     } catch (Dali::DaliException e) {
19046       {
19047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19048       };
19049     } catch (...) {
19050       {
19051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19052       };
19053     }
19054   }
19055
19056 }
19057
19058
19059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19060   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19061
19062   arg1 = (Dali::ConnectionTracker *)jarg1;
19063   {
19064     try {
19065       (arg1)->DisconnectAll();
19066     } catch (std::out_of_range& e) {
19067       {
19068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19069       };
19070     } catch (std::exception& e) {
19071       {
19072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19073       };
19074     } catch (Dali::DaliException e) {
19075       {
19076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19077       };
19078     } catch (...) {
19079       {
19080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19081       };
19082     }
19083   }
19084
19085 }
19086
19087
19088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19089   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19090   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19091   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19092
19093   arg1 = (Dali::ConnectionTracker *)jarg1;
19094   arg2 = (Dali::SlotObserver *)jarg2;
19095   arg3 = (Dali::CallbackBase *)jarg3;
19096   {
19097     try {
19098       (arg1)->SignalConnected(arg2,arg3);
19099     } catch (std::out_of_range& e) {
19100       {
19101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19102       };
19103     } catch (std::exception& e) {
19104       {
19105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19106       };
19107     } catch (Dali::DaliException e) {
19108       {
19109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19110       };
19111     } catch (...) {
19112       {
19113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19114       };
19115     }
19116   }
19117
19118 }
19119
19120
19121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19122   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19123   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19124   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19125
19126   arg1 = (Dali::ConnectionTracker *)jarg1;
19127   arg2 = (Dali::SlotObserver *)jarg2;
19128   arg3 = (Dali::CallbackBase *)jarg3;
19129   {
19130     try {
19131       (arg1)->SignalDisconnected(arg2,arg3);
19132     } catch (std::out_of_range& e) {
19133       {
19134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19135       };
19136     } catch (std::exception& e) {
19137       {
19138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19139       };
19140     } catch (Dali::DaliException e) {
19141       {
19142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19143       };
19144     } catch (...) {
19145       {
19146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19147       };
19148     }
19149   }
19150
19151 }
19152
19153
19154 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19155   unsigned long jresult ;
19156   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19157   std::size_t result;
19158
19159   arg1 = (Dali::ConnectionTracker *)jarg1;
19160   {
19161     try {
19162       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19163     } catch (std::out_of_range& e) {
19164       {
19165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19166       };
19167     } catch (std::exception& e) {
19168       {
19169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19170       };
19171     } catch (Dali::DaliException e) {
19172       {
19173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19174       };
19175     } catch (...) {
19176       {
19177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19178       };
19179     }
19180   }
19181
19182   jresult = (unsigned long)result;
19183   return jresult;
19184 }
19185
19186
19187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19188   void * jresult ;
19189   Dali::ObjectRegistry *result = 0 ;
19190
19191   {
19192     try {
19193       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19194     } catch (std::out_of_range& e) {
19195       {
19196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19197       };
19198     } catch (std::exception& e) {
19199       {
19200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19201       };
19202     } catch (Dali::DaliException e) {
19203       {
19204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19205       };
19206     } catch (...) {
19207       {
19208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19209       };
19210     }
19211   }
19212
19213   jresult = (void *)result;
19214   return jresult;
19215 }
19216
19217
19218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19219   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19220
19221   arg1 = (Dali::ObjectRegistry *)jarg1;
19222   {
19223     try {
19224       delete arg1;
19225     } catch (std::out_of_range& e) {
19226       {
19227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19228       };
19229     } catch (std::exception& e) {
19230       {
19231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19232       };
19233     } catch (Dali::DaliException e) {
19234       {
19235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19236       };
19237     } catch (...) {
19238       {
19239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19240       };
19241     }
19242   }
19243
19244 }
19245
19246
19247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19248   void * jresult ;
19249   Dali::ObjectRegistry *arg1 = 0 ;
19250   Dali::ObjectRegistry *result = 0 ;
19251
19252   arg1 = (Dali::ObjectRegistry *)jarg1;
19253   if (!arg1) {
19254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19255     return 0;
19256   }
19257   {
19258     try {
19259       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19260     } catch (std::out_of_range& e) {
19261       {
19262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19263       };
19264     } catch (std::exception& e) {
19265       {
19266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19267       };
19268     } catch (Dali::DaliException e) {
19269       {
19270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19271       };
19272     } catch (...) {
19273       {
19274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19275       };
19276     }
19277   }
19278
19279   jresult = (void *)result;
19280   return jresult;
19281 }
19282
19283
19284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19285   void * jresult ;
19286   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19287   Dali::ObjectRegistry *arg2 = 0 ;
19288   Dali::ObjectRegistry *result = 0 ;
19289
19290   arg1 = (Dali::ObjectRegistry *)jarg1;
19291   arg2 = (Dali::ObjectRegistry *)jarg2;
19292   if (!arg2) {
19293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19294     return 0;
19295   }
19296   {
19297     try {
19298       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19299     } catch (std::out_of_range& e) {
19300       {
19301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19302       };
19303     } catch (std::exception& e) {
19304       {
19305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19306       };
19307     } catch (Dali::DaliException e) {
19308       {
19309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19310       };
19311     } catch (...) {
19312       {
19313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19314       };
19315     }
19316   }
19317
19318   jresult = (void *)result;
19319   return jresult;
19320 }
19321
19322
19323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19324   void * jresult ;
19325   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19326   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19327
19328   arg1 = (Dali::ObjectRegistry *)jarg1;
19329   {
19330     try {
19331       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19332     } catch (std::out_of_range& e) {
19333       {
19334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19335       };
19336     } catch (std::exception& e) {
19337       {
19338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19339       };
19340     } catch (Dali::DaliException e) {
19341       {
19342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19343       };
19344     } catch (...) {
19345       {
19346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19347       };
19348     }
19349   }
19350
19351   jresult = (void *)result;
19352   return jresult;
19353 }
19354
19355
19356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19357   void * jresult ;
19358   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19359   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19360
19361   arg1 = (Dali::ObjectRegistry *)jarg1;
19362   {
19363     try {
19364       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19365     } catch (std::out_of_range& e) {
19366       {
19367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19368       };
19369     } catch (std::exception& e) {
19370       {
19371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19372       };
19373     } catch (Dali::DaliException e) {
19374       {
19375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19376       };
19377     } catch (...) {
19378       {
19379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19380       };
19381     }
19382   }
19383
19384   jresult = (void *)result;
19385   return jresult;
19386 }
19387
19388
19389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19390   void * jresult ;
19391   Dali::PropertyCondition *result = 0 ;
19392
19393   {
19394     try {
19395       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19396     } catch (std::out_of_range& e) {
19397       {
19398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19399       };
19400     } catch (std::exception& e) {
19401       {
19402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19403       };
19404     } catch (Dali::DaliException e) {
19405       {
19406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19407       };
19408     } catch (...) {
19409       {
19410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19411       };
19412     }
19413   }
19414
19415   jresult = (void *)result;
19416   return jresult;
19417 }
19418
19419
19420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19421   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19422
19423   arg1 = (Dali::PropertyCondition *)jarg1;
19424   {
19425     try {
19426       delete arg1;
19427     } catch (std::out_of_range& e) {
19428       {
19429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19430       };
19431     } catch (std::exception& e) {
19432       {
19433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19434       };
19435     } catch (Dali::DaliException e) {
19436       {
19437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19438       };
19439     } catch (...) {
19440       {
19441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19442       };
19443     }
19444   }
19445
19446 }
19447
19448
19449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19450   void * jresult ;
19451   Dali::PropertyCondition *arg1 = 0 ;
19452   Dali::PropertyCondition *result = 0 ;
19453
19454   arg1 = (Dali::PropertyCondition *)jarg1;
19455   if (!arg1) {
19456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19457     return 0;
19458   }
19459   {
19460     try {
19461       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19462     } catch (std::out_of_range& e) {
19463       {
19464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19465       };
19466     } catch (std::exception& e) {
19467       {
19468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19469       };
19470     } catch (Dali::DaliException e) {
19471       {
19472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19473       };
19474     } catch (...) {
19475       {
19476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19477       };
19478     }
19479   }
19480
19481   jresult = (void *)result;
19482   return jresult;
19483 }
19484
19485
19486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19487   void * jresult ;
19488   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19489   Dali::PropertyCondition *arg2 = 0 ;
19490   Dali::PropertyCondition *result = 0 ;
19491
19492   arg1 = (Dali::PropertyCondition *)jarg1;
19493   arg2 = (Dali::PropertyCondition *)jarg2;
19494   if (!arg2) {
19495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19496     return 0;
19497   }
19498   {
19499     try {
19500       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19501     } catch (std::out_of_range& e) {
19502       {
19503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19504       };
19505     } catch (std::exception& e) {
19506       {
19507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19508       };
19509     } catch (Dali::DaliException e) {
19510       {
19511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19512       };
19513     } catch (...) {
19514       {
19515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19516       };
19517     }
19518   }
19519
19520   jresult = (void *)result;
19521   return jresult;
19522 }
19523
19524
19525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19526   unsigned long jresult ;
19527   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19528   std::size_t result;
19529
19530   arg1 = (Dali::PropertyCondition *)jarg1;
19531   {
19532     try {
19533       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19534     } catch (std::out_of_range& e) {
19535       {
19536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19537       };
19538     } catch (std::exception& e) {
19539       {
19540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19541       };
19542     } catch (...) {
19543       {
19544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19545       };
19546     }
19547   }
19548   jresult = (unsigned long)result;
19549   return jresult;
19550 }
19551
19552
19553 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19554   float jresult ;
19555   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19556   std::size_t arg2 ;
19557   float result;
19558
19559   arg1 = (Dali::PropertyCondition *)jarg1;
19560   arg2 = (std::size_t)jarg2;
19561   {
19562     try {
19563       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19564     } catch (std::out_of_range& e) {
19565       {
19566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19567       };
19568     } catch (std::exception& e) {
19569       {
19570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19571       };
19572     } catch (...) {
19573       {
19574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19575       };
19576     }
19577   }
19578   jresult = result;
19579   return jresult;
19580 }
19581
19582
19583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19584   void * jresult ;
19585   float arg1 ;
19586   Dali::PropertyCondition result;
19587
19588   arg1 = (float)jarg1;
19589   {
19590     try {
19591       result = Dali::LessThanCondition(arg1);
19592     } catch (std::out_of_range& e) {
19593       {
19594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19595       };
19596     } catch (std::exception& e) {
19597       {
19598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19599       };
19600     } catch (Dali::DaliException e) {
19601       {
19602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19603       };
19604     } catch (...) {
19605       {
19606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19607       };
19608     }
19609   }
19610
19611   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19612   return jresult;
19613 }
19614
19615
19616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19617   void * jresult ;
19618   float arg1 ;
19619   Dali::PropertyCondition result;
19620
19621   arg1 = (float)jarg1;
19622   {
19623     try {
19624       result = Dali::GreaterThanCondition(arg1);
19625     } catch (std::out_of_range& e) {
19626       {
19627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19628       };
19629     } catch (std::exception& e) {
19630       {
19631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19632       };
19633     } catch (Dali::DaliException e) {
19634       {
19635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19636       };
19637     } catch (...) {
19638       {
19639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19640       };
19641     }
19642   }
19643
19644   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19645   return jresult;
19646 }
19647
19648
19649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19650   void * jresult ;
19651   float arg1 ;
19652   float arg2 ;
19653   Dali::PropertyCondition result;
19654
19655   arg1 = (float)jarg1;
19656   arg2 = (float)jarg2;
19657   {
19658     try {
19659       result = Dali::InsideCondition(arg1,arg2);
19660     } catch (std::out_of_range& e) {
19661       {
19662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19663       };
19664     } catch (std::exception& e) {
19665       {
19666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19667       };
19668     } catch (Dali::DaliException e) {
19669       {
19670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19671       };
19672     } catch (...) {
19673       {
19674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19675       };
19676     }
19677   }
19678
19679   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19680   return jresult;
19681 }
19682
19683
19684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19685   void * jresult ;
19686   float arg1 ;
19687   float arg2 ;
19688   Dali::PropertyCondition result;
19689
19690   arg1 = (float)jarg1;
19691   arg2 = (float)jarg2;
19692   {
19693     try {
19694       result = Dali::OutsideCondition(arg1,arg2);
19695     } catch (std::out_of_range& e) {
19696       {
19697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19698       };
19699     } catch (std::exception& e) {
19700       {
19701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19702       };
19703     } catch (Dali::DaliException e) {
19704       {
19705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19706       };
19707     } catch (...) {
19708       {
19709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19710       };
19711     }
19712   }
19713
19714   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19715   return jresult;
19716 }
19717
19718
19719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19720   void * jresult ;
19721   float arg1 ;
19722   float arg2 ;
19723   Dali::PropertyCondition result;
19724
19725   arg1 = (float)jarg1;
19726   arg2 = (float)jarg2;
19727   {
19728     try {
19729       result = Dali::StepCondition(arg1,arg2);
19730     } catch (std::out_of_range& e) {
19731       {
19732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19733       };
19734     } catch (std::exception& e) {
19735       {
19736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19737       };
19738     } catch (Dali::DaliException e) {
19739       {
19740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19741       };
19742     } catch (...) {
19743       {
19744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19745       };
19746     }
19747   }
19748
19749   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19750   return jresult;
19751 }
19752
19753
19754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19755   void * jresult ;
19756   float arg1 ;
19757   Dali::PropertyCondition result;
19758
19759   arg1 = (float)jarg1;
19760   {
19761     try {
19762       result = Dali::StepCondition(arg1);
19763     } catch (std::out_of_range& e) {
19764       {
19765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19766       };
19767     } catch (std::exception& e) {
19768       {
19769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19770       };
19771     } catch (Dali::DaliException e) {
19772       {
19773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19774       };
19775     } catch (...) {
19776       {
19777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19778       };
19779     }
19780   }
19781
19782   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19783   return jresult;
19784 }
19785
19786
19787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19788   void * jresult ;
19789   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19790   Dali::PropertyCondition result;
19791
19792   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19793   if (!arg1) {
19794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19795     return 0;
19796   }
19797   {
19798     try {
19799       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19800     } catch (std::out_of_range& e) {
19801       {
19802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19803       };
19804     } catch (std::exception& e) {
19805       {
19806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19807       };
19808     } catch (Dali::DaliException e) {
19809       {
19810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19811       };
19812     } catch (...) {
19813       {
19814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19815       };
19816     }
19817   }
19818
19819   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19820   return jresult;
19821 }
19822
19823
19824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19825   void * jresult ;
19826   Dali::PropertyNotification *result = 0 ;
19827
19828   {
19829     try {
19830       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19831     } catch (std::out_of_range& e) {
19832       {
19833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19834       };
19835     } catch (std::exception& e) {
19836       {
19837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19838       };
19839     } catch (Dali::DaliException e) {
19840       {
19841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19842       };
19843     } catch (...) {
19844       {
19845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19846       };
19847     }
19848   }
19849
19850   jresult = (void *)result;
19851   return jresult;
19852 }
19853
19854
19855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19856   void * jresult ;
19857   Dali::BaseHandle arg1 ;
19858   Dali::BaseHandle *argp1 ;
19859   Dali::PropertyNotification result;
19860
19861   argp1 = (Dali::BaseHandle *)jarg1;
19862   if (!argp1) {
19863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19864     return 0;
19865   }
19866   arg1 = *argp1;
19867   {
19868     try {
19869       result = Dali::PropertyNotification::DownCast(arg1);
19870     } catch (std::out_of_range& e) {
19871       {
19872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19873       };
19874     } catch (std::exception& e) {
19875       {
19876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19877       };
19878     } catch (Dali::DaliException e) {
19879       {
19880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19881       };
19882     } catch (...) {
19883       {
19884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19885       };
19886     }
19887   }
19888
19889   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19890   return jresult;
19891 }
19892
19893
19894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19895   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19896
19897   arg1 = (Dali::PropertyNotification *)jarg1;
19898   {
19899     try {
19900       delete arg1;
19901     } catch (std::out_of_range& e) {
19902       {
19903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19904       };
19905     } catch (std::exception& e) {
19906       {
19907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19908       };
19909     } catch (Dali::DaliException e) {
19910       {
19911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19912       };
19913     } catch (...) {
19914       {
19915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19916       };
19917     }
19918   }
19919
19920 }
19921
19922
19923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19924   void * jresult ;
19925   Dali::PropertyNotification *arg1 = 0 ;
19926   Dali::PropertyNotification *result = 0 ;
19927
19928   arg1 = (Dali::PropertyNotification *)jarg1;
19929   if (!arg1) {
19930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19931     return 0;
19932   }
19933   {
19934     try {
19935       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19936     } catch (std::out_of_range& e) {
19937       {
19938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19939       };
19940     } catch (std::exception& e) {
19941       {
19942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19943       };
19944     } catch (Dali::DaliException e) {
19945       {
19946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19947       };
19948     } catch (...) {
19949       {
19950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19951       };
19952     }
19953   }
19954
19955   jresult = (void *)result;
19956   return jresult;
19957 }
19958
19959
19960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19961   void * jresult ;
19962   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19963   Dali::PropertyNotification *arg2 = 0 ;
19964   Dali::PropertyNotification *result = 0 ;
19965
19966   arg1 = (Dali::PropertyNotification *)jarg1;
19967   arg2 = (Dali::PropertyNotification *)jarg2;
19968   if (!arg2) {
19969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19970     return 0;
19971   }
19972   {
19973     try {
19974       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19975     } catch (std::out_of_range& e) {
19976       {
19977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19978       };
19979     } catch (std::exception& e) {
19980       {
19981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19982       };
19983     } catch (Dali::DaliException e) {
19984       {
19985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19986       };
19987     } catch (...) {
19988       {
19989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19990       };
19991     }
19992   }
19993
19994   jresult = (void *)result;
19995   return jresult;
19996 }
19997
19998
19999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20000   void * jresult ;
20001   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20002   Dali::PropertyCondition result;
20003
20004   arg1 = (Dali::PropertyNotification *)jarg1;
20005   {
20006     try {
20007       result = (arg1)->GetCondition();
20008     } catch (std::out_of_range& e) {
20009       {
20010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20011       };
20012     } catch (std::exception& e) {
20013       {
20014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20015       };
20016     } catch (Dali::DaliException e) {
20017       {
20018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20019       };
20020     } catch (...) {
20021       {
20022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20023       };
20024     }
20025   }
20026
20027   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20028   return jresult;
20029 }
20030
20031
20032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20033   void * jresult ;
20034   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20035   Dali::Handle result;
20036
20037   arg1 = (Dali::PropertyNotification *)jarg1;
20038   {
20039     try {
20040       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20041     } catch (std::out_of_range& e) {
20042       {
20043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20044       };
20045     } catch (std::exception& e) {
20046       {
20047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20048       };
20049     } catch (Dali::DaliException e) {
20050       {
20051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20052       };
20053     } catch (...) {
20054       {
20055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20056       };
20057     }
20058   }
20059
20060   jresult = new Dali::Handle((const Dali::Handle &)result);
20061   return jresult;
20062 }
20063
20064
20065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20066   int jresult ;
20067   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20068   Dali::Property::Index result;
20069
20070   arg1 = (Dali::PropertyNotification *)jarg1;
20071   {
20072     try {
20073       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20074     } catch (std::out_of_range& e) {
20075       {
20076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20077       };
20078     } catch (std::exception& e) {
20079       {
20080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20081       };
20082     } catch (Dali::DaliException e) {
20083       {
20084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20085       };
20086     } catch (...) {
20087       {
20088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20089       };
20090     }
20091   }
20092
20093   jresult = result;
20094   return jresult;
20095 }
20096
20097
20098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20099   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20100   Dali::PropertyNotification::NotifyMode arg2 ;
20101
20102   arg1 = (Dali::PropertyNotification *)jarg1;
20103   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20104   {
20105     try {
20106       (arg1)->SetNotifyMode(arg2);
20107     } catch (std::out_of_range& e) {
20108       {
20109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20110       };
20111     } catch (std::exception& e) {
20112       {
20113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20114       };
20115     } catch (Dali::DaliException e) {
20116       {
20117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20118       };
20119     } catch (...) {
20120       {
20121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20122       };
20123     }
20124   }
20125
20126 }
20127
20128
20129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20130   int jresult ;
20131   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20132   Dali::PropertyNotification::NotifyMode result;
20133
20134   arg1 = (Dali::PropertyNotification *)jarg1;
20135   {
20136     try {
20137       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20138     } catch (std::out_of_range& e) {
20139       {
20140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20141       };
20142     } catch (std::exception& e) {
20143       {
20144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20145       };
20146     } catch (Dali::DaliException e) {
20147       {
20148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20149       };
20150     } catch (...) {
20151       {
20152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20153       };
20154     }
20155   }
20156
20157   jresult = (int)result;
20158   return jresult;
20159 }
20160
20161
20162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20163   unsigned int jresult ;
20164   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20165   bool result;
20166
20167   arg1 = (Dali::PropertyNotification *)jarg1;
20168   {
20169     try {
20170       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20171     } catch (std::out_of_range& e) {
20172       {
20173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20174       };
20175     } catch (std::exception& e) {
20176       {
20177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20178       };
20179     } catch (Dali::DaliException e) {
20180       {
20181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20182       };
20183     } catch (...) {
20184       {
20185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20186       };
20187     }
20188   }
20189
20190   jresult = result;
20191   return jresult;
20192 }
20193
20194
20195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20196   void * jresult ;
20197   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20198   Dali::PropertyNotifySignalType *result = 0 ;
20199
20200   arg1 = (Dali::PropertyNotification *)jarg1;
20201   {
20202     try {
20203       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20204     } catch (std::out_of_range& e) {
20205       {
20206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20207       };
20208     } catch (std::exception& e) {
20209       {
20210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20211       };
20212     } catch (Dali::DaliException e) {
20213       {
20214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20215       };
20216     } catch (...) {
20217       {
20218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20219       };
20220     }
20221   }
20222
20223   jresult = (void *)result;
20224   return jresult;
20225 }
20226
20227
20228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20229   void * jresult ;
20230   Dali::Handle *result = 0 ;
20231
20232   {
20233     try {
20234       result = (Dali::Handle *)new Dali::Handle();
20235     } catch (std::out_of_range& e) {
20236       {
20237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20238       };
20239     } catch (std::exception& e) {
20240       {
20241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20242       };
20243     } catch (Dali::DaliException e) {
20244       {
20245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20246       };
20247     } catch (...) {
20248       {
20249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20250       };
20251     }
20252   }
20253
20254   jresult = (void *)result;
20255   return jresult;
20256 }
20257
20258
20259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20260   void * jresult ;
20261   Dali::Handle result;
20262
20263   {
20264     try {
20265       result = Dali::Handle::New();
20266     } catch (std::out_of_range& e) {
20267       {
20268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20269       };
20270     } catch (std::exception& e) {
20271       {
20272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20273       };
20274     } catch (Dali::DaliException e) {
20275       {
20276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20277       };
20278     } catch (...) {
20279       {
20280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20281       };
20282     }
20283   }
20284
20285   jresult = new Dali::Handle((const Dali::Handle &)result);
20286   return jresult;
20287 }
20288
20289
20290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20291   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20292
20293   arg1 = (Dali::Handle *)jarg1;
20294   {
20295     try {
20296       delete arg1;
20297     } catch (std::out_of_range& e) {
20298       {
20299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20300       };
20301     } catch (std::exception& e) {
20302       {
20303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20304       };
20305     } catch (Dali::DaliException e) {
20306       {
20307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20308       };
20309     } catch (...) {
20310       {
20311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20312       };
20313     }
20314   }
20315
20316 }
20317
20318
20319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20320   void * jresult ;
20321   Dali::Handle *arg1 = 0 ;
20322   Dali::Handle *result = 0 ;
20323
20324   arg1 = (Dali::Handle *)jarg1;
20325   if (!arg1) {
20326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20327     return 0;
20328   }
20329   {
20330     try {
20331       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20332     } catch (std::out_of_range& e) {
20333       {
20334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20335       };
20336     } catch (std::exception& e) {
20337       {
20338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20339       };
20340     } catch (Dali::DaliException e) {
20341       {
20342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20343       };
20344     } catch (...) {
20345       {
20346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20347       };
20348     }
20349   }
20350
20351   jresult = (void *)result;
20352   return jresult;
20353 }
20354
20355
20356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20357   void * jresult ;
20358   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20359   Dali::Handle *arg2 = 0 ;
20360   Dali::Handle *result = 0 ;
20361
20362   arg1 = (Dali::Handle *)jarg1;
20363   arg2 = (Dali::Handle *)jarg2;
20364   if (!arg2) {
20365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20366     return 0;
20367   }
20368   {
20369     try {
20370       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20371     } catch (std::out_of_range& e) {
20372       {
20373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20374       };
20375     } catch (std::exception& e) {
20376       {
20377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20378       };
20379     } catch (Dali::DaliException e) {
20380       {
20381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20382       };
20383     } catch (...) {
20384       {
20385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20386       };
20387     }
20388   }
20389
20390   jresult = (void *)result;
20391   return jresult;
20392 }
20393
20394
20395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20396   void * jresult ;
20397   Dali::BaseHandle arg1 ;
20398   Dali::BaseHandle *argp1 ;
20399   Dali::Handle result;
20400
20401   argp1 = (Dali::BaseHandle *)jarg1;
20402   if (!argp1) {
20403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20404     return 0;
20405   }
20406   arg1 = *argp1;
20407   {
20408     try {
20409       result = Dali::Handle::DownCast(arg1);
20410     } catch (std::out_of_range& e) {
20411       {
20412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20413       };
20414     } catch (std::exception& e) {
20415       {
20416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20417       };
20418     } catch (Dali::DaliException e) {
20419       {
20420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20421       };
20422     } catch (...) {
20423       {
20424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20425       };
20426     }
20427   }
20428
20429   jresult = new Dali::Handle((const Dali::Handle &)result);
20430   return jresult;
20431 }
20432
20433
20434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20435   unsigned int jresult ;
20436   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20437   Dali::Handle::Capability arg2 ;
20438   bool result;
20439
20440   arg1 = (Dali::Handle *)jarg1;
20441   arg2 = (Dali::Handle::Capability)jarg2;
20442   {
20443     try {
20444       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20445     } catch (std::out_of_range& e) {
20446       {
20447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20448       };
20449     } catch (std::exception& e) {
20450       {
20451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20452       };
20453     } catch (Dali::DaliException e) {
20454       {
20455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20456       };
20457     } catch (...) {
20458       {
20459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20460       };
20461     }
20462   }
20463
20464   jresult = result;
20465   return jresult;
20466 }
20467
20468
20469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20470   unsigned int jresult ;
20471   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20472   unsigned int result;
20473
20474   arg1 = (Dali::Handle *)jarg1;
20475   {
20476     try {
20477       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20478     } catch (std::out_of_range& e) {
20479       {
20480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20481       };
20482     } catch (std::exception& e) {
20483       {
20484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20485       };
20486     } catch (Dali::DaliException e) {
20487       {
20488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20489       };
20490     } catch (...) {
20491       {
20492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20493       };
20494     }
20495   }
20496
20497   jresult = result;
20498   return jresult;
20499 }
20500
20501
20502 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20503   char * jresult ;
20504   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20505   Dali::Property::Index arg2 ;
20506   std::string result;
20507
20508   arg1 = (Dali::Handle *)jarg1;
20509   arg2 = (Dali::Property::Index)jarg2;
20510   {
20511     try {
20512       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20513     } catch (std::out_of_range& e) {
20514       {
20515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20516       };
20517     } catch (std::exception& e) {
20518       {
20519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20520       };
20521     } catch (Dali::DaliException e) {
20522       {
20523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20524       };
20525     } catch (...) {
20526       {
20527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20528       };
20529     }
20530   }
20531
20532   jresult = SWIG_csharp_string_callback((&result)->c_str());
20533   return jresult;
20534 }
20535
20536
20537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20538   int jresult ;
20539   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20540   std::string *arg2 = 0 ;
20541   Dali::Property::Index result;
20542
20543   arg1 = (Dali::Handle *)jarg1;
20544   if (!jarg2) {
20545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20546     return 0;
20547   }
20548   std::string arg2_str(jarg2);
20549   arg2 = &arg2_str;
20550   {
20551     try {
20552       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20553     } catch (std::out_of_range& e) {
20554       {
20555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20556       };
20557     } catch (std::exception& e) {
20558       {
20559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20560       };
20561     } catch (Dali::DaliException e) {
20562       {
20563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20564       };
20565     } catch (...) {
20566       {
20567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20568       };
20569     }
20570   }
20571
20572   jresult = result;
20573
20574   //argout typemap for const std::string&
20575
20576   return jresult;
20577 }
20578
20579
20580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20581   unsigned int jresult ;
20582   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20583   Dali::Property::Index arg2 ;
20584   bool result;
20585
20586   arg1 = (Dali::Handle *)jarg1;
20587   arg2 = (Dali::Property::Index)jarg2;
20588   {
20589     try {
20590       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20591     } catch (std::out_of_range& e) {
20592       {
20593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20594       };
20595     } catch (std::exception& e) {
20596       {
20597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20598       };
20599     } catch (Dali::DaliException e) {
20600       {
20601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20602       };
20603     } catch (...) {
20604       {
20605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20606       };
20607     }
20608   }
20609
20610   jresult = result;
20611   return jresult;
20612 }
20613
20614
20615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20616   unsigned int jresult ;
20617   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20618   Dali::Property::Index arg2 ;
20619   bool result;
20620
20621   arg1 = (Dali::Handle *)jarg1;
20622   arg2 = (Dali::Property::Index)jarg2;
20623   {
20624     try {
20625       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20626     } catch (std::out_of_range& e) {
20627       {
20628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20629       };
20630     } catch (std::exception& e) {
20631       {
20632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20633       };
20634     } catch (Dali::DaliException e) {
20635       {
20636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20637       };
20638     } catch (...) {
20639       {
20640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20641       };
20642     }
20643   }
20644
20645   jresult = result;
20646   return jresult;
20647 }
20648
20649
20650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20651   unsigned int jresult ;
20652   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20653   Dali::Property::Index arg2 ;
20654   bool result;
20655
20656   arg1 = (Dali::Handle *)jarg1;
20657   arg2 = (Dali::Property::Index)jarg2;
20658   {
20659     try {
20660       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20661     } catch (std::out_of_range& e) {
20662       {
20663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20664       };
20665     } catch (std::exception& e) {
20666       {
20667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20668       };
20669     } catch (Dali::DaliException e) {
20670       {
20671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20672       };
20673     } catch (...) {
20674       {
20675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20676       };
20677     }
20678   }
20679
20680   jresult = result;
20681   return jresult;
20682 }
20683
20684
20685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20686   int jresult ;
20687   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20688   Dali::Property::Index arg2 ;
20689   Dali::Property::Type result;
20690
20691   arg1 = (Dali::Handle *)jarg1;
20692   arg2 = (Dali::Property::Index)jarg2;
20693   {
20694     try {
20695       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20696     } catch (std::out_of_range& e) {
20697       {
20698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20699       };
20700     } catch (std::exception& e) {
20701       {
20702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20703       };
20704     } catch (Dali::DaliException e) {
20705       {
20706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20707       };
20708     } catch (...) {
20709       {
20710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20711       };
20712     }
20713   }
20714
20715   jresult = (int)result;
20716   return jresult;
20717 }
20718
20719
20720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20721   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20722   Dali::Property::Index arg2 ;
20723   Dali::Property::Value *arg3 = 0 ;
20724
20725   arg1 = (Dali::Handle *)jarg1;
20726   arg2 = (Dali::Property::Index)jarg2;
20727   arg3 = (Dali::Property::Value *)jarg3;
20728   if (!arg3) {
20729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20730     return ;
20731   }
20732   {
20733     try {
20734       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20735     } catch (std::out_of_range& e) {
20736       {
20737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20738       };
20739     } catch (std::exception& e) {
20740       {
20741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20742       };
20743     } catch (Dali::DaliException e) {
20744       {
20745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20746       };
20747     } catch (...) {
20748       {
20749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20750       };
20751     }
20752   }
20753
20754 }
20755
20756
20757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20758   int jresult ;
20759   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20760   std::string *arg2 = 0 ;
20761   Dali::Property::Value *arg3 = 0 ;
20762   Dali::Property::Index result;
20763
20764   arg1 = (Dali::Handle *)jarg1;
20765   if (!jarg2) {
20766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20767     return 0;
20768   }
20769   std::string arg2_str(jarg2);
20770   arg2 = &arg2_str;
20771   arg3 = (Dali::Property::Value *)jarg3;
20772   if (!arg3) {
20773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20774     return 0;
20775   }
20776   {
20777     try {
20778       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20779     } catch (std::out_of_range& e) {
20780       {
20781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20782       };
20783     } catch (std::exception& e) {
20784       {
20785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20786       };
20787     } catch (Dali::DaliException e) {
20788       {
20789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20790       };
20791     } catch (...) {
20792       {
20793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20794       };
20795     }
20796   }
20797
20798   jresult = result;
20799
20800   //argout typemap for const std::string&
20801
20802   return jresult;
20803 }
20804
20805
20806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20807   int jresult ;
20808   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20809   std::string *arg2 = 0 ;
20810   Dali::Property::Value *arg3 = 0 ;
20811   Dali::Property::AccessMode arg4 ;
20812   Dali::Property::Index result;
20813
20814   arg1 = (Dali::Handle *)jarg1;
20815   if (!jarg2) {
20816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20817     return 0;
20818   }
20819   std::string arg2_str(jarg2);
20820   arg2 = &arg2_str;
20821   arg3 = (Dali::Property::Value *)jarg3;
20822   if (!arg3) {
20823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20824     return 0;
20825   }
20826   arg4 = (Dali::Property::AccessMode)jarg4;
20827   {
20828     try {
20829       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20830     } catch (std::out_of_range& e) {
20831       {
20832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20833       };
20834     } catch (std::exception& e) {
20835       {
20836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20837       };
20838     } catch (Dali::DaliException e) {
20839       {
20840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20841       };
20842     } catch (...) {
20843       {
20844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20845       };
20846     }
20847   }
20848
20849   jresult = result;
20850
20851   //argout typemap for const std::string&
20852
20853   return jresult;
20854 }
20855
20856
20857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20858   void * jresult ;
20859   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20860   Dali::Property::Index arg2 ;
20861   Dali::Property::Value result;
20862
20863   arg1 = (Dali::Handle *)jarg1;
20864   arg2 = (Dali::Property::Index)jarg2;
20865   {
20866     try {
20867       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20868     } catch (std::out_of_range& e) {
20869       {
20870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (std::exception& e) {
20873       {
20874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20875       };
20876     } catch (Dali::DaliException e) {
20877       {
20878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20879       };
20880     } catch (...) {
20881       {
20882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20883       };
20884     }
20885   }
20886
20887   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20888   return jresult;
20889 }
20890
20891
20892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20893   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20894   Dali::Property::IndexContainer *arg2 = 0 ;
20895
20896   arg1 = (Dali::Handle *)jarg1;
20897   arg2 = (Dali::Property::IndexContainer *)jarg2;
20898   if (!arg2) {
20899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20900     return ;
20901   }
20902   {
20903     try {
20904       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20905     } catch (std::out_of_range& e) {
20906       {
20907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20908       };
20909     } catch (std::exception& e) {
20910       {
20911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20912       };
20913     } catch (Dali::DaliException e) {
20914       {
20915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20916       };
20917     } catch (...) {
20918       {
20919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20920       };
20921     }
20922   }
20923
20924 }
20925
20926
20927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20928   void * jresult ;
20929   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20930   Dali::Property::Index arg2 ;
20931   Dali::PropertyCondition *arg3 = 0 ;
20932   Dali::PropertyNotification result;
20933
20934   arg1 = (Dali::Handle *)jarg1;
20935   arg2 = (Dali::Property::Index)jarg2;
20936   arg3 = (Dali::PropertyCondition *)jarg3;
20937   if (!arg3) {
20938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20939     return 0;
20940   }
20941   {
20942     try {
20943       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20944     } catch (std::out_of_range& e) {
20945       {
20946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20947       };
20948     } catch (std::exception& e) {
20949       {
20950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20951       };
20952     } catch (Dali::DaliException e) {
20953       {
20954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20955       };
20956     } catch (...) {
20957       {
20958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20959       };
20960     }
20961   }
20962
20963   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20964   return jresult;
20965 }
20966
20967
20968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20969   void * jresult ;
20970   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20971   Dali::Property::Index arg2 ;
20972   int arg3 ;
20973   Dali::PropertyCondition *arg4 = 0 ;
20974   Dali::PropertyNotification result;
20975
20976   arg1 = (Dali::Handle *)jarg1;
20977   arg2 = (Dali::Property::Index)jarg2;
20978   arg3 = (int)jarg3;
20979   arg4 = (Dali::PropertyCondition *)jarg4;
20980   if (!arg4) {
20981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20982     return 0;
20983   }
20984   {
20985     try {
20986       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20987     } catch (std::out_of_range& e) {
20988       {
20989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (std::exception& e) {
20992       {
20993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20994       };
20995     } catch (Dali::DaliException e) {
20996       {
20997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20998       };
20999     } catch (...) {
21000       {
21001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21002       };
21003     }
21004   }
21005
21006   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21007   return jresult;
21008 }
21009
21010
21011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21012   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21013   Dali::PropertyNotification arg2 ;
21014   Dali::PropertyNotification *argp2 ;
21015
21016   arg1 = (Dali::Handle *)jarg1;
21017   argp2 = (Dali::PropertyNotification *)jarg2;
21018   if (!argp2) {
21019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21020     return ;
21021   }
21022   arg2 = *argp2;
21023   {
21024     try {
21025       (arg1)->RemovePropertyNotification(arg2);
21026     } catch (std::out_of_range& e) {
21027       {
21028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21029       };
21030     } catch (std::exception& e) {
21031       {
21032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21033       };
21034     } catch (Dali::DaliException e) {
21035       {
21036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21037       };
21038     } catch (...) {
21039       {
21040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21041       };
21042     }
21043   }
21044
21045 }
21046
21047
21048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21049   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21050
21051   arg1 = (Dali::Handle *)jarg1;
21052   {
21053     try {
21054       (arg1)->RemovePropertyNotifications();
21055     } catch (std::out_of_range& e) {
21056       {
21057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21058       };
21059     } catch (std::exception& e) {
21060       {
21061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21062       };
21063     } catch (Dali::DaliException e) {
21064       {
21065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21066       };
21067     } catch (...) {
21068       {
21069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21070       };
21071     }
21072   }
21073
21074 }
21075
21076
21077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21078   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21079
21080   arg1 = (Dali::Handle *)jarg1;
21081   {
21082     try {
21083       (arg1)->RemoveConstraints();
21084     } catch (std::out_of_range& e) {
21085       {
21086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21087       };
21088     } catch (std::exception& e) {
21089       {
21090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21091       };
21092     } catch (Dali::DaliException e) {
21093       {
21094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21095       };
21096     } catch (...) {
21097       {
21098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21099       };
21100     }
21101   }
21102
21103 }
21104
21105
21106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21107   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21108   unsigned int arg2 ;
21109
21110   arg1 = (Dali::Handle *)jarg1;
21111   arg2 = (unsigned int)jarg2;
21112   {
21113     try {
21114       (arg1)->RemoveConstraints(arg2);
21115     } catch (std::out_of_range& e) {
21116       {
21117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21118       };
21119     } catch (std::exception& e) {
21120       {
21121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21122       };
21123     } catch (Dali::DaliException e) {
21124       {
21125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21126       };
21127     } catch (...) {
21128       {
21129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21130       };
21131     }
21132   }
21133
21134 }
21135
21136
21137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21138   int jresult ;
21139   Dali::Property::Index result;
21140
21141   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21142   jresult = result;
21143   return jresult;
21144 }
21145
21146
21147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21148   void * jresult ;
21149   Dali::Handle result;
21150
21151   {
21152     try {
21153       result = Dali::WeightObject::New();
21154     } catch (std::out_of_range& e) {
21155       {
21156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21157       };
21158     } catch (std::exception& e) {
21159       {
21160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21161       };
21162     } catch (Dali::DaliException e) {
21163       {
21164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21165       };
21166     } catch (...) {
21167       {
21168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21169       };
21170     }
21171   }
21172
21173   jresult = new Dali::Handle((const Dali::Handle &)result);
21174   return jresult;
21175 }
21176
21177
21178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21179   void * jresult ;
21180   Dali::TypeInfo *result = 0 ;
21181
21182   {
21183     try {
21184       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21185     } catch (std::out_of_range& e) {
21186       {
21187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21188       };
21189     } catch (std::exception& e) {
21190       {
21191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21192       };
21193     } catch (Dali::DaliException e) {
21194       {
21195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21196       };
21197     } catch (...) {
21198       {
21199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21200       };
21201     }
21202   }
21203
21204   jresult = (void *)result;
21205   return jresult;
21206 }
21207
21208
21209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21210   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21211
21212   arg1 = (Dali::TypeInfo *)jarg1;
21213   {
21214     try {
21215       delete arg1;
21216     } catch (std::out_of_range& e) {
21217       {
21218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21219       };
21220     } catch (std::exception& e) {
21221       {
21222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21223       };
21224     } catch (Dali::DaliException e) {
21225       {
21226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21227       };
21228     } catch (...) {
21229       {
21230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21231       };
21232     }
21233   }
21234
21235 }
21236
21237
21238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21239   void * jresult ;
21240   Dali::TypeInfo *arg1 = 0 ;
21241   Dali::TypeInfo *result = 0 ;
21242
21243   arg1 = (Dali::TypeInfo *)jarg1;
21244   if (!arg1) {
21245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21246     return 0;
21247   }
21248   {
21249     try {
21250       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21251     } catch (std::out_of_range& e) {
21252       {
21253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21254       };
21255     } catch (std::exception& e) {
21256       {
21257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21258       };
21259     } catch (Dali::DaliException e) {
21260       {
21261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21262       };
21263     } catch (...) {
21264       {
21265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21266       };
21267     }
21268   }
21269
21270   jresult = (void *)result;
21271   return jresult;
21272 }
21273
21274
21275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21276   void * jresult ;
21277   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21278   Dali::TypeInfo *arg2 = 0 ;
21279   Dali::TypeInfo *result = 0 ;
21280
21281   arg1 = (Dali::TypeInfo *)jarg1;
21282   arg2 = (Dali::TypeInfo *)jarg2;
21283   if (!arg2) {
21284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21285     return 0;
21286   }
21287   {
21288     try {
21289       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21290     } catch (std::out_of_range& e) {
21291       {
21292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21293       };
21294     } catch (std::exception& e) {
21295       {
21296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21297       };
21298     } catch (Dali::DaliException e) {
21299       {
21300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21301       };
21302     } catch (...) {
21303       {
21304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21305       };
21306     }
21307   }
21308
21309   jresult = (void *)result;
21310   return jresult;
21311 }
21312
21313
21314 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21315   char * jresult ;
21316   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21317   std::string *result = 0 ;
21318
21319   arg1 = (Dali::TypeInfo *)jarg1;
21320   {
21321     try {
21322       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21323     } catch (std::out_of_range& e) {
21324       {
21325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21326       };
21327     } catch (std::exception& e) {
21328       {
21329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21330       };
21331     } catch (Dali::DaliException e) {
21332       {
21333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21334       };
21335     } catch (...) {
21336       {
21337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21338       };
21339     }
21340   }
21341
21342   jresult = SWIG_csharp_string_callback(result->c_str());
21343   return jresult;
21344 }
21345
21346
21347 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21348   char * jresult ;
21349   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21350   std::string *result = 0 ;
21351
21352   arg1 = (Dali::TypeInfo *)jarg1;
21353   {
21354     try {
21355       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21356     } catch (std::out_of_range& e) {
21357       {
21358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21359       };
21360     } catch (std::exception& e) {
21361       {
21362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21363       };
21364     } catch (Dali::DaliException e) {
21365       {
21366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21367       };
21368     } catch (...) {
21369       {
21370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21371       };
21372     }
21373   }
21374
21375   jresult = SWIG_csharp_string_callback(result->c_str());
21376   return jresult;
21377 }
21378
21379
21380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21381   void * jresult ;
21382   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21383   Dali::BaseHandle result;
21384
21385   arg1 = (Dali::TypeInfo *)jarg1;
21386   {
21387     try {
21388       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21389     } catch (std::out_of_range& e) {
21390       {
21391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21392       };
21393     } catch (std::exception& e) {
21394       {
21395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21396       };
21397     } catch (Dali::DaliException e) {
21398       {
21399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21400       };
21401     } catch (...) {
21402       {
21403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21404       };
21405     }
21406   }
21407
21408   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21409   return jresult;
21410 }
21411
21412
21413 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21414   unsigned long jresult ;
21415   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21416   size_t result;
21417
21418   arg1 = (Dali::TypeInfo *)jarg1;
21419   {
21420     try {
21421       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21422     } catch (std::out_of_range& e) {
21423       {
21424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21425       };
21426     } catch (std::exception& e) {
21427       {
21428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21429       };
21430     } catch (Dali::DaliException e) {
21431       {
21432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21433       };
21434     } catch (...) {
21435       {
21436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21437       };
21438     }
21439   }
21440
21441   jresult = (unsigned long)result;
21442   return jresult;
21443 }
21444
21445
21446 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21447   char * jresult ;
21448   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21449   size_t arg2 ;
21450   std::string result;
21451
21452   arg1 = (Dali::TypeInfo *)jarg1;
21453   arg2 = (size_t)jarg2;
21454   {
21455     try {
21456       result = (arg1)->GetActionName(arg2);
21457     } catch (std::out_of_range& e) {
21458       {
21459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21460       };
21461     } catch (std::exception& e) {
21462       {
21463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21464       };
21465     } catch (Dali::DaliException e) {
21466       {
21467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21468       };
21469     } catch (...) {
21470       {
21471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21472       };
21473     }
21474   }
21475
21476   jresult = SWIG_csharp_string_callback((&result)->c_str());
21477   return jresult;
21478 }
21479
21480
21481 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21482   unsigned long jresult ;
21483   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21484   size_t result;
21485
21486   arg1 = (Dali::TypeInfo *)jarg1;
21487   {
21488     try {
21489       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21490     } catch (std::out_of_range& e) {
21491       {
21492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21493       };
21494     } catch (std::exception& e) {
21495       {
21496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21497       };
21498     } catch (Dali::DaliException e) {
21499       {
21500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21501       };
21502     } catch (...) {
21503       {
21504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21505       };
21506     }
21507   }
21508
21509   jresult = (unsigned long)result;
21510   return jresult;
21511 }
21512
21513
21514 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21515   char * jresult ;
21516   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21517   size_t arg2 ;
21518   std::string result;
21519
21520   arg1 = (Dali::TypeInfo *)jarg1;
21521   arg2 = (size_t)jarg2;
21522   {
21523     try {
21524       result = (arg1)->GetSignalName(arg2);
21525     } catch (std::out_of_range& e) {
21526       {
21527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21528       };
21529     } catch (std::exception& e) {
21530       {
21531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21532       };
21533     } catch (Dali::DaliException e) {
21534       {
21535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21536       };
21537     } catch (...) {
21538       {
21539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21540       };
21541     }
21542   }
21543
21544   jresult = SWIG_csharp_string_callback((&result)->c_str());
21545   return jresult;
21546 }
21547
21548
21549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21550   unsigned long jresult ;
21551   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21552   size_t result;
21553
21554   arg1 = (Dali::TypeInfo *)jarg1;
21555   {
21556     try {
21557       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21558     } catch (std::out_of_range& e) {
21559       {
21560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21561       };
21562     } catch (std::exception& e) {
21563       {
21564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21565       };
21566     } catch (Dali::DaliException e) {
21567       {
21568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21569       };
21570     } catch (...) {
21571       {
21572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21573       };
21574     }
21575   }
21576
21577   jresult = (unsigned long)result;
21578   return jresult;
21579 }
21580
21581
21582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21583   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21584   Dali::Property::IndexContainer *arg2 = 0 ;
21585
21586   arg1 = (Dali::TypeInfo *)jarg1;
21587   arg2 = (Dali::Property::IndexContainer *)jarg2;
21588   if (!arg2) {
21589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21590     return ;
21591   }
21592   {
21593     try {
21594       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21595     } catch (std::out_of_range& e) {
21596       {
21597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21598       };
21599     } catch (std::exception& e) {
21600       {
21601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21602       };
21603     } catch (Dali::DaliException e) {
21604       {
21605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21606       };
21607     } catch (...) {
21608       {
21609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21610       };
21611     }
21612   }
21613
21614 }
21615
21616
21617 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21618   char * jresult ;
21619   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21620   Dali::Property::Index arg2 ;
21621   std::string *result = 0 ;
21622
21623   arg1 = (Dali::TypeInfo *)jarg1;
21624   arg2 = (Dali::Property::Index)jarg2;
21625   {
21626     try {
21627       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21628     } catch (std::out_of_range& e) {
21629       {
21630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21631       };
21632     } catch (std::exception& e) {
21633       {
21634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21635       };
21636     } catch (Dali::DaliException e) {
21637       {
21638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21639       };
21640     } catch (...) {
21641       {
21642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21643       };
21644     }
21645   }
21646
21647   jresult = SWIG_csharp_string_callback(result->c_str());
21648   return jresult;
21649 }
21650
21651
21652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21653   void * jresult ;
21654   Dali::TypeRegistry result;
21655
21656   {
21657     try {
21658       result = Dali::TypeRegistry::Get();
21659     } catch (std::out_of_range& e) {
21660       {
21661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21662       };
21663     } catch (std::exception& e) {
21664       {
21665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21666       };
21667     } catch (Dali::DaliException e) {
21668       {
21669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21670       };
21671     } catch (...) {
21672       {
21673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21674       };
21675     }
21676   }
21677
21678   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21679   return jresult;
21680 }
21681
21682
21683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21684   void * jresult ;
21685   Dali::TypeRegistry *result = 0 ;
21686
21687   {
21688     try {
21689       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21690     } catch (std::out_of_range& e) {
21691       {
21692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21693       };
21694     } catch (std::exception& e) {
21695       {
21696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21697       };
21698     } catch (Dali::DaliException e) {
21699       {
21700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21701       };
21702     } catch (...) {
21703       {
21704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21705       };
21706     }
21707   }
21708
21709   jresult = (void *)result;
21710   return jresult;
21711 }
21712
21713
21714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21715   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21716
21717   arg1 = (Dali::TypeRegistry *)jarg1;
21718   {
21719     try {
21720       delete arg1;
21721     } catch (std::out_of_range& e) {
21722       {
21723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21724       };
21725     } catch (std::exception& e) {
21726       {
21727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21728       };
21729     } catch (Dali::DaliException e) {
21730       {
21731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21732       };
21733     } catch (...) {
21734       {
21735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21736       };
21737     }
21738   }
21739
21740 }
21741
21742
21743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21744   void * jresult ;
21745   Dali::TypeRegistry *arg1 = 0 ;
21746   Dali::TypeRegistry *result = 0 ;
21747
21748   arg1 = (Dali::TypeRegistry *)jarg1;
21749   if (!arg1) {
21750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21751     return 0;
21752   }
21753   {
21754     try {
21755       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21756     } catch (std::out_of_range& e) {
21757       {
21758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21759       };
21760     } catch (std::exception& e) {
21761       {
21762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21763       };
21764     } catch (Dali::DaliException e) {
21765       {
21766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21767       };
21768     } catch (...) {
21769       {
21770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21771       };
21772     }
21773   }
21774
21775   jresult = (void *)result;
21776   return jresult;
21777 }
21778
21779
21780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21781   void * jresult ;
21782   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21783   Dali::TypeRegistry *arg2 = 0 ;
21784   Dali::TypeRegistry *result = 0 ;
21785
21786   arg1 = (Dali::TypeRegistry *)jarg1;
21787   arg2 = (Dali::TypeRegistry *)jarg2;
21788   if (!arg2) {
21789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21790     return 0;
21791   }
21792   {
21793     try {
21794       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21795     } catch (std::out_of_range& e) {
21796       {
21797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21798       };
21799     } catch (std::exception& e) {
21800       {
21801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21802       };
21803     } catch (Dali::DaliException e) {
21804       {
21805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21806       };
21807     } catch (...) {
21808       {
21809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21810       };
21811     }
21812   }
21813
21814   jresult = (void *)result;
21815   return jresult;
21816 }
21817
21818
21819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21820   void * jresult ;
21821   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21822   std::string *arg2 = 0 ;
21823   Dali::TypeInfo result;
21824
21825   arg1 = (Dali::TypeRegistry *)jarg1;
21826   if (!jarg2) {
21827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21828     return 0;
21829   }
21830   std::string arg2_str(jarg2);
21831   arg2 = &arg2_str;
21832   {
21833     try {
21834       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21835     } catch (std::out_of_range& e) {
21836       {
21837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21838       };
21839     } catch (std::exception& e) {
21840       {
21841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21842       };
21843     } catch (Dali::DaliException e) {
21844       {
21845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21846       };
21847     } catch (...) {
21848       {
21849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21850       };
21851     }
21852   }
21853
21854   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21855
21856   //argout typemap for const std::string&
21857
21858   return jresult;
21859 }
21860
21861
21862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21863   void * jresult ;
21864   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21865   std::type_info *arg2 = 0 ;
21866   Dali::TypeInfo result;
21867
21868   arg1 = (Dali::TypeRegistry *)jarg1;
21869   arg2 = (std::type_info *)jarg2;
21870   if (!arg2) {
21871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21872     return 0;
21873   }
21874   {
21875     try {
21876       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21877     } catch (std::out_of_range& e) {
21878       {
21879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21880       };
21881     } catch (std::exception& e) {
21882       {
21883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21884       };
21885     } catch (Dali::DaliException e) {
21886       {
21887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21888       };
21889     } catch (...) {
21890       {
21891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21892       };
21893     }
21894   }
21895
21896   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21897   return jresult;
21898 }
21899
21900
21901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21902   unsigned long jresult ;
21903   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21904   size_t result;
21905
21906   arg1 = (Dali::TypeRegistry *)jarg1;
21907   {
21908     try {
21909       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21910     } catch (std::out_of_range& e) {
21911       {
21912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21913       };
21914     } catch (std::exception& e) {
21915       {
21916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21917       };
21918     } catch (Dali::DaliException e) {
21919       {
21920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21921       };
21922     } catch (...) {
21923       {
21924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21925       };
21926     }
21927   }
21928
21929   jresult = (unsigned long)result;
21930   return jresult;
21931 }
21932
21933
21934 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21935   char * jresult ;
21936   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21937   size_t arg2 ;
21938   std::string result;
21939
21940   arg1 = (Dali::TypeRegistry *)jarg1;
21941   arg2 = (size_t)jarg2;
21942   {
21943     try {
21944       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21945     } catch (std::out_of_range& e) {
21946       {
21947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21948       };
21949     } catch (std::exception& e) {
21950       {
21951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21952       };
21953     } catch (Dali::DaliException e) {
21954       {
21955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21956       };
21957     } catch (...) {
21958       {
21959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21960       };
21961     }
21962   }
21963
21964   jresult = SWIG_csharp_string_callback((&result)->c_str());
21965   return jresult;
21966 }
21967
21968
21969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21970   void * jresult ;
21971   std::type_info *arg1 = 0 ;
21972   std::type_info *arg2 = 0 ;
21973   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21974   Dali::TypeRegistration *result = 0 ;
21975
21976   arg1 = (std::type_info *)jarg1;
21977   if (!arg1) {
21978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21979     return 0;
21980   }
21981   arg2 = (std::type_info *)jarg2;
21982   if (!arg2) {
21983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21984     return 0;
21985   }
21986   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21987   {
21988     try {
21989       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21990     } catch (std::out_of_range& e) {
21991       {
21992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21993       };
21994     } catch (std::exception& e) {
21995       {
21996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21997       };
21998     } catch (Dali::DaliException e) {
21999       {
22000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22001       };
22002     } catch (...) {
22003       {
22004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22005       };
22006     }
22007   }
22008
22009   jresult = (void *)result;
22010   return jresult;
22011 }
22012
22013
22014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22015   void * jresult ;
22016   std::type_info *arg1 = 0 ;
22017   std::type_info *arg2 = 0 ;
22018   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22019   bool arg4 ;
22020   Dali::TypeRegistration *result = 0 ;
22021
22022   arg1 = (std::type_info *)jarg1;
22023   if (!arg1) {
22024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22025     return 0;
22026   }
22027   arg2 = (std::type_info *)jarg2;
22028   if (!arg2) {
22029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22030     return 0;
22031   }
22032   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22033   arg4 = jarg4 ? true : false;
22034   {
22035     try {
22036       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22037     } catch (std::out_of_range& e) {
22038       {
22039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22040       };
22041     } catch (std::exception& e) {
22042       {
22043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22044       };
22045     } catch (Dali::DaliException e) {
22046       {
22047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22048       };
22049     } catch (...) {
22050       {
22051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22052       };
22053     }
22054   }
22055
22056   jresult = (void *)result;
22057   return jresult;
22058 }
22059
22060
22061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22062   void * jresult ;
22063   std::string *arg1 = 0 ;
22064   std::type_info *arg2 = 0 ;
22065   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22066   Dali::TypeRegistration *result = 0 ;
22067
22068   if (!jarg1) {
22069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22070     return 0;
22071   }
22072   std::string arg1_str(jarg1);
22073   arg1 = &arg1_str;
22074   arg2 = (std::type_info *)jarg2;
22075   if (!arg2) {
22076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22077     return 0;
22078   }
22079   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22080   {
22081     try {
22082       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22083     } catch (std::out_of_range& e) {
22084       {
22085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22086       };
22087     } catch (std::exception& e) {
22088       {
22089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22090       };
22091     } catch (Dali::DaliException e) {
22092       {
22093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22094       };
22095     } catch (...) {
22096       {
22097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22098       };
22099     }
22100   }
22101
22102   jresult = (void *)result;
22103
22104   //argout typemap for const std::string&
22105
22106   return jresult;
22107 }
22108
22109
22110 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22111   char * jresult ;
22112   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22113   std::string result;
22114
22115   arg1 = (Dali::TypeRegistration *)jarg1;
22116   {
22117     try {
22118       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22119     } catch (std::out_of_range& e) {
22120       {
22121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22122       };
22123     } catch (std::exception& e) {
22124       {
22125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22126       };
22127     } catch (Dali::DaliException e) {
22128       {
22129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22130       };
22131     } catch (...) {
22132       {
22133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22134       };
22135     }
22136   }
22137
22138   jresult = SWIG_csharp_string_callback((&result)->c_str());
22139   return jresult;
22140 }
22141
22142
22143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22144   std::string *arg1 = 0 ;
22145   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22146
22147   if (!jarg1) {
22148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22149     return ;
22150   }
22151   std::string arg1_str(jarg1);
22152   arg1 = &arg1_str;
22153   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22154   {
22155     try {
22156       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22157     } catch (std::out_of_range& e) {
22158       {
22159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22160       };
22161     } catch (std::exception& e) {
22162       {
22163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22164       };
22165     } catch (Dali::DaliException e) {
22166       {
22167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22168       };
22169     } catch (...) {
22170       {
22171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22172       };
22173     }
22174   }
22175
22176
22177   //argout typemap for const std::string&
22178
22179 }
22180
22181
22182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22183   std::string *arg1 = 0 ;
22184   std::string *arg2 = 0 ;
22185   int arg3 ;
22186   Dali::Property::Type arg4 ;
22187   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22188   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22189
22190   if (!jarg1) {
22191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22192     return ;
22193   }
22194   std::string arg1_str(jarg1);
22195   arg1 = &arg1_str;
22196   if (!jarg2) {
22197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22198     return ;
22199   }
22200   std::string arg2_str(jarg2);
22201   arg2 = &arg2_str;
22202   arg3 = (int)jarg3;
22203   arg4 = (Dali::Property::Type)jarg4;
22204   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22205   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22206   {
22207     try {
22208       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22209     } catch (std::out_of_range& e) {
22210       {
22211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22212       };
22213     } catch (std::exception& e) {
22214       {
22215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22216       };
22217     } catch (Dali::DaliException e) {
22218       {
22219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22220       };
22221     } catch (...) {
22222       {
22223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22224       };
22225     }
22226   }
22227
22228
22229   //argout typemap for const std::string&
22230
22231
22232   //argout typemap for const std::string&
22233
22234 }
22235
22236
22237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22238   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22239
22240   arg1 = (Dali::TypeRegistration *)jarg1;
22241   {
22242     try {
22243       delete arg1;
22244     } catch (std::out_of_range& e) {
22245       {
22246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22247       };
22248     } catch (std::exception& e) {
22249       {
22250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22251       };
22252     } catch (Dali::DaliException e) {
22253       {
22254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22255       };
22256     } catch (...) {
22257       {
22258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22259       };
22260     }
22261   }
22262
22263 }
22264
22265
22266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22267   void * jresult ;
22268   Dali::TypeRegistration *arg1 = 0 ;
22269   std::string *arg2 = 0 ;
22270   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22271   Dali::SignalConnectorType *result = 0 ;
22272
22273   arg1 = (Dali::TypeRegistration *)jarg1;
22274   if (!arg1) {
22275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22276     return 0;
22277   }
22278   if (!jarg2) {
22279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22280     return 0;
22281   }
22282   std::string arg2_str(jarg2);
22283   arg2 = &arg2_str;
22284   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22285   {
22286     try {
22287       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22288     } catch (std::out_of_range& e) {
22289       {
22290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22291       };
22292     } catch (std::exception& e) {
22293       {
22294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22295       };
22296     } catch (Dali::DaliException e) {
22297       {
22298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22299       };
22300     } catch (...) {
22301       {
22302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22303       };
22304     }
22305   }
22306
22307   jresult = (void *)result;
22308
22309   //argout typemap for const std::string&
22310
22311   return jresult;
22312 }
22313
22314
22315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22316   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22317
22318   arg1 = (Dali::SignalConnectorType *)jarg1;
22319   {
22320     try {
22321       delete arg1;
22322     } catch (std::out_of_range& e) {
22323       {
22324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22325       };
22326     } catch (std::exception& e) {
22327       {
22328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22329       };
22330     } catch (Dali::DaliException e) {
22331       {
22332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22333       };
22334     } catch (...) {
22335       {
22336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22337       };
22338     }
22339   }
22340
22341 }
22342
22343
22344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22345   void * jresult ;
22346   Dali::TypeRegistration *arg1 = 0 ;
22347   std::string *arg2 = 0 ;
22348   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22349   Dali::TypeAction *result = 0 ;
22350
22351   arg1 = (Dali::TypeRegistration *)jarg1;
22352   if (!arg1) {
22353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22354     return 0;
22355   }
22356   if (!jarg2) {
22357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22358     return 0;
22359   }
22360   std::string arg2_str(jarg2);
22361   arg2 = &arg2_str;
22362   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22363   {
22364     try {
22365       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22366     } catch (std::out_of_range& e) {
22367       {
22368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22369       };
22370     } catch (std::exception& e) {
22371       {
22372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22373       };
22374     } catch (Dali::DaliException e) {
22375       {
22376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22377       };
22378     } catch (...) {
22379       {
22380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22381       };
22382     }
22383   }
22384
22385   jresult = (void *)result;
22386
22387   //argout typemap for const std::string&
22388
22389   return jresult;
22390 }
22391
22392
22393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22394   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22395
22396   arg1 = (Dali::TypeAction *)jarg1;
22397   {
22398     try {
22399       delete arg1;
22400     } catch (std::out_of_range& e) {
22401       {
22402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22403       };
22404     } catch (std::exception& e) {
22405       {
22406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22407       };
22408     } catch (Dali::DaliException e) {
22409       {
22410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22411       };
22412     } catch (...) {
22413       {
22414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22415       };
22416     }
22417   }
22418
22419 }
22420
22421
22422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22423   void * jresult ;
22424   Dali::TypeRegistration *arg1 = 0 ;
22425   std::string *arg2 = 0 ;
22426   Dali::Property::Index arg3 ;
22427   Dali::Property::Type arg4 ;
22428   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22429   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22430   Dali::PropertyRegistration *result = 0 ;
22431
22432   arg1 = (Dali::TypeRegistration *)jarg1;
22433   if (!arg1) {
22434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22435     return 0;
22436   }
22437   if (!jarg2) {
22438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22439     return 0;
22440   }
22441   std::string arg2_str(jarg2);
22442   arg2 = &arg2_str;
22443   arg3 = (Dali::Property::Index)jarg3;
22444   arg4 = (Dali::Property::Type)jarg4;
22445   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22446   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22447   {
22448     try {
22449       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22450     } catch (std::out_of_range& e) {
22451       {
22452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22453       };
22454     } catch (std::exception& e) {
22455       {
22456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22457       };
22458     } catch (Dali::DaliException e) {
22459       {
22460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22461       };
22462     } catch (...) {
22463       {
22464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22465       };
22466     }
22467   }
22468
22469   jresult = (void *)result;
22470
22471   //argout typemap for const std::string&
22472
22473   return jresult;
22474 }
22475
22476
22477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22478   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22479
22480   arg1 = (Dali::PropertyRegistration *)jarg1;
22481   {
22482     try {
22483       delete arg1;
22484     } catch (std::out_of_range& e) {
22485       {
22486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22487       };
22488     } catch (std::exception& e) {
22489       {
22490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22491       };
22492     } catch (Dali::DaliException e) {
22493       {
22494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22495       };
22496     } catch (...) {
22497       {
22498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22499       };
22500     }
22501   }
22502
22503 }
22504
22505
22506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22507   void * jresult ;
22508   Dali::TypeRegistration *arg1 = 0 ;
22509   std::string *arg2 = 0 ;
22510   Dali::Property::Index arg3 ;
22511   Dali::Property::Type arg4 ;
22512   Dali::AnimatablePropertyRegistration *result = 0 ;
22513
22514   arg1 = (Dali::TypeRegistration *)jarg1;
22515   if (!arg1) {
22516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22517     return 0;
22518   }
22519   if (!jarg2) {
22520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22521     return 0;
22522   }
22523   std::string arg2_str(jarg2);
22524   arg2 = &arg2_str;
22525   arg3 = (Dali::Property::Index)jarg3;
22526   arg4 = (Dali::Property::Type)jarg4;
22527   {
22528     try {
22529       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22530     } catch (std::out_of_range& e) {
22531       {
22532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22533       };
22534     } catch (std::exception& e) {
22535       {
22536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22537       };
22538     } catch (Dali::DaliException e) {
22539       {
22540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22541       };
22542     } catch (...) {
22543       {
22544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22545       };
22546     }
22547   }
22548
22549   jresult = (void *)result;
22550
22551   //argout typemap for const std::string&
22552
22553   return jresult;
22554 }
22555
22556
22557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22558   void * jresult ;
22559   Dali::TypeRegistration *arg1 = 0 ;
22560   std::string *arg2 = 0 ;
22561   Dali::Property::Index arg3 ;
22562   Dali::Property::Value *arg4 = 0 ;
22563   Dali::AnimatablePropertyRegistration *result = 0 ;
22564
22565   arg1 = (Dali::TypeRegistration *)jarg1;
22566   if (!arg1) {
22567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22568     return 0;
22569   }
22570   if (!jarg2) {
22571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22572     return 0;
22573   }
22574   std::string arg2_str(jarg2);
22575   arg2 = &arg2_str;
22576   arg3 = (Dali::Property::Index)jarg3;
22577   arg4 = (Dali::Property::Value *)jarg4;
22578   if (!arg4) {
22579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22580     return 0;
22581   }
22582   {
22583     try {
22584       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22585     } catch (std::out_of_range& e) {
22586       {
22587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22588       };
22589     } catch (std::exception& e) {
22590       {
22591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22592       };
22593     } catch (Dali::DaliException e) {
22594       {
22595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22596       };
22597     } catch (...) {
22598       {
22599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22600       };
22601     }
22602   }
22603
22604   jresult = (void *)result;
22605
22606   //argout typemap for const std::string&
22607
22608   return jresult;
22609 }
22610
22611
22612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22613   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22614
22615   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22616   {
22617     try {
22618       delete arg1;
22619     } catch (std::out_of_range& e) {
22620       {
22621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22622       };
22623     } catch (std::exception& e) {
22624       {
22625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22626       };
22627     } catch (Dali::DaliException e) {
22628       {
22629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22630       };
22631     } catch (...) {
22632       {
22633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22634       };
22635     }
22636   }
22637
22638 }
22639
22640
22641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22642   void * jresult ;
22643   Dali::TypeRegistration *arg1 = 0 ;
22644   std::string *arg2 = 0 ;
22645   Dali::Property::Index arg3 ;
22646   Dali::Property::Index arg4 ;
22647   unsigned int arg5 ;
22648   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22649
22650   arg1 = (Dali::TypeRegistration *)jarg1;
22651   if (!arg1) {
22652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22653     return 0;
22654   }
22655   if (!jarg2) {
22656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22657     return 0;
22658   }
22659   std::string arg2_str(jarg2);
22660   arg2 = &arg2_str;
22661   arg3 = (Dali::Property::Index)jarg3;
22662   arg4 = (Dali::Property::Index)jarg4;
22663   arg5 = (unsigned int)jarg5;
22664   {
22665     try {
22666       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22667     } catch (std::out_of_range& e) {
22668       {
22669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22670       };
22671     } catch (std::exception& e) {
22672       {
22673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22674       };
22675     } catch (Dali::DaliException e) {
22676       {
22677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22678       };
22679     } catch (...) {
22680       {
22681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22682       };
22683     }
22684   }
22685
22686   jresult = (void *)result;
22687
22688   //argout typemap for const std::string&
22689
22690   return jresult;
22691 }
22692
22693
22694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22695   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22696
22697   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22698   {
22699     try {
22700       delete arg1;
22701     } catch (std::out_of_range& e) {
22702       {
22703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22704       };
22705     } catch (std::exception& e) {
22706       {
22707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22708       };
22709     } catch (Dali::DaliException e) {
22710       {
22711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22712       };
22713     } catch (...) {
22714       {
22715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22716       };
22717     }
22718   }
22719
22720 }
22721
22722
22723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22724   void * jresult ;
22725   Dali::TypeRegistration *arg1 = 0 ;
22726   std::string *arg2 = 0 ;
22727   Dali::Property::Index arg3 ;
22728   Dali::Property::Type arg4 ;
22729   Dali::ChildPropertyRegistration *result = 0 ;
22730
22731   arg1 = (Dali::TypeRegistration *)jarg1;
22732   if (!arg1) {
22733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22734     return 0;
22735   }
22736   if (!jarg2) {
22737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22738     return 0;
22739   }
22740   std::string arg2_str(jarg2);
22741   arg2 = &arg2_str;
22742   arg3 = (Dali::Property::Index)jarg3;
22743   arg4 = (Dali::Property::Type)jarg4;
22744   {
22745     try {
22746       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22747     } catch (std::out_of_range& e) {
22748       {
22749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22750       };
22751     } catch (std::exception& e) {
22752       {
22753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22754       };
22755     } catch (Dali::DaliException e) {
22756       {
22757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22758       };
22759     } catch (...) {
22760       {
22761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22762       };
22763     }
22764   }
22765
22766   jresult = (void *)result;
22767
22768   //argout typemap for const std::string&
22769
22770   return jresult;
22771 }
22772
22773
22774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22775   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22776
22777   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22778   {
22779     try {
22780       delete arg1;
22781     } catch (std::out_of_range& e) {
22782       {
22783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22784       };
22785     } catch (std::exception& e) {
22786       {
22787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22788       };
22789     } catch (Dali::DaliException e) {
22790       {
22791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22792       };
22793     } catch (...) {
22794       {
22795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22796       };
22797     }
22798   }
22799
22800 }
22801
22802
22803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22804   unsigned int jresult ;
22805   std::string *arg1 = 0 ;
22806   std::type_info *arg2 = 0 ;
22807   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22808   bool result;
22809
22810   if (!jarg1) {
22811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22812     return 0;
22813   }
22814   std::string arg1_str(jarg1);
22815   arg1 = &arg1_str;
22816   arg2 = (std::type_info *)jarg2;
22817   if (!arg2) {
22818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22819     return 0;
22820   }
22821   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22822   {
22823     try {
22824       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22825     } catch (std::out_of_range& e) {
22826       {
22827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22828       };
22829     } catch (std::exception& e) {
22830       {
22831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22832       };
22833     } catch (Dali::DaliException e) {
22834       {
22835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22836       };
22837     } catch (...) {
22838       {
22839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22840       };
22841     }
22842   }
22843
22844   jresult = result;
22845
22846   //argout typemap for const std::string&
22847
22848   return jresult;
22849 }
22850
22851
22852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22853   unsigned int jresult ;
22854   std::string *arg1 = 0 ;
22855   std::string *arg2 = 0 ;
22856   Dali::Property::Index arg3 ;
22857   Dali::Property::Type arg4 ;
22858   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22859   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22860   bool result;
22861
22862   if (!jarg1) {
22863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22864     return 0;
22865   }
22866   std::string arg1_str(jarg1);
22867   arg1 = &arg1_str;
22868   if (!jarg2) {
22869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22870     return 0;
22871   }
22872   std::string arg2_str(jarg2);
22873   arg2 = &arg2_str;
22874   arg3 = (Dali::Property::Index)jarg3;
22875   arg4 = (Dali::Property::Type)jarg4;
22876   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22877   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22878   {
22879     try {
22880       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22881     } catch (std::out_of_range& e) {
22882       {
22883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22884       };
22885     } catch (std::exception& e) {
22886       {
22887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22888       };
22889     } catch (Dali::DaliException e) {
22890       {
22891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22892       };
22893     } catch (...) {
22894       {
22895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22896       };
22897     }
22898   }
22899
22900   jresult = result;
22901
22902   //argout typemap for const std::string&
22903
22904
22905   //argout typemap for const std::string&
22906
22907   return jresult;
22908 }
22909
22910
22911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22912   float jresult ;
22913   float result;
22914
22915   result = (float)(float)Dali::ParentOrigin::TOP;
22916   jresult = result;
22917   return jresult;
22918 }
22919
22920
22921 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22922   float jresult ;
22923   float result;
22924
22925   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22926   jresult = result;
22927   return jresult;
22928 }
22929
22930
22931 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22932   float jresult ;
22933   float result;
22934
22935   result = (float)(float)Dali::ParentOrigin::LEFT;
22936   jresult = result;
22937   return jresult;
22938 }
22939
22940
22941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22942   float jresult ;
22943   float result;
22944
22945   result = (float)(float)Dali::ParentOrigin::RIGHT;
22946   jresult = result;
22947   return jresult;
22948 }
22949
22950
22951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22952   float jresult ;
22953   float result;
22954
22955   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22956   jresult = result;
22957   return jresult;
22958 }
22959
22960
22961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22962   void * jresult ;
22963   Dali::Vector3 *result = 0 ;
22964
22965   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22966   jresult = (void *)result;
22967   return jresult;
22968 }
22969
22970
22971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22972   void * jresult ;
22973   Dali::Vector3 *result = 0 ;
22974
22975   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22976   jresult = (void *)result;
22977   return jresult;
22978 }
22979
22980
22981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22982   void * jresult ;
22983   Dali::Vector3 *result = 0 ;
22984
22985   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22986   jresult = (void *)result;
22987   return jresult;
22988 }
22989
22990
22991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22992   void * jresult ;
22993   Dali::Vector3 *result = 0 ;
22994
22995   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22996   jresult = (void *)result;
22997   return jresult;
22998 }
22999
23000
23001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23002   void * jresult ;
23003   Dali::Vector3 *result = 0 ;
23004
23005   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23006   jresult = (void *)result;
23007   return jresult;
23008 }
23009
23010
23011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23012   void * jresult ;
23013   Dali::Vector3 *result = 0 ;
23014
23015   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23016   jresult = (void *)result;
23017   return jresult;
23018 }
23019
23020
23021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23022   void * jresult ;
23023   Dali::Vector3 *result = 0 ;
23024
23025   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23026   jresult = (void *)result;
23027   return jresult;
23028 }
23029
23030
23031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23032   void * jresult ;
23033   Dali::Vector3 *result = 0 ;
23034
23035   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23036   jresult = (void *)result;
23037   return jresult;
23038 }
23039
23040
23041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23042   void * jresult ;
23043   Dali::Vector3 *result = 0 ;
23044
23045   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23046   jresult = (void *)result;
23047   return jresult;
23048 }
23049
23050
23051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23052   float jresult ;
23053   float result;
23054
23055   result = (float)(float)Dali::AnchorPoint::TOP;
23056   jresult = result;
23057   return jresult;
23058 }
23059
23060
23061 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23062   float jresult ;
23063   float result;
23064
23065   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23066   jresult = result;
23067   return jresult;
23068 }
23069
23070
23071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23072   float jresult ;
23073   float result;
23074
23075   result = (float)(float)Dali::AnchorPoint::LEFT;
23076   jresult = result;
23077   return jresult;
23078 }
23079
23080
23081 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23082   float jresult ;
23083   float result;
23084
23085   result = (float)(float)Dali::AnchorPoint::RIGHT;
23086   jresult = result;
23087   return jresult;
23088 }
23089
23090
23091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23092   float jresult ;
23093   float result;
23094
23095   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23096   jresult = result;
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23102   void * jresult ;
23103   Dali::Vector3 *result = 0 ;
23104
23105   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23106   jresult = (void *)result;
23107   return jresult;
23108 }
23109
23110
23111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23112   void * jresult ;
23113   Dali::Vector3 *result = 0 ;
23114
23115   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23116   jresult = (void *)result;
23117   return jresult;
23118 }
23119
23120
23121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23122   void * jresult ;
23123   Dali::Vector3 *result = 0 ;
23124
23125   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23126   jresult = (void *)result;
23127   return jresult;
23128 }
23129
23130
23131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23132   void * jresult ;
23133   Dali::Vector3 *result = 0 ;
23134
23135   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23136   jresult = (void *)result;
23137   return jresult;
23138 }
23139
23140
23141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23142   void * jresult ;
23143   Dali::Vector3 *result = 0 ;
23144
23145   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23146   jresult = (void *)result;
23147   return jresult;
23148 }
23149
23150
23151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23152   void * jresult ;
23153   Dali::Vector3 *result = 0 ;
23154
23155   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23156   jresult = (void *)result;
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23162   void * jresult ;
23163   Dali::Vector3 *result = 0 ;
23164
23165   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23166   jresult = (void *)result;
23167   return jresult;
23168 }
23169
23170
23171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23172   void * jresult ;
23173   Dali::Vector3 *result = 0 ;
23174
23175   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23176   jresult = (void *)result;
23177   return jresult;
23178 }
23179
23180
23181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23182   void * jresult ;
23183   Dali::Vector3 *result = 0 ;
23184
23185   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23186   jresult = (void *)result;
23187   return jresult;
23188 }
23189
23190
23191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23192   void * jresult ;
23193   Dali::Vector4 *result = 0 ;
23194
23195   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23196   jresult = (void *)result;
23197   return jresult;
23198 }
23199
23200
23201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23202   void * jresult ;
23203   Dali::Vector4 *result = 0 ;
23204
23205   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23206   jresult = (void *)result;
23207   return jresult;
23208 }
23209
23210
23211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23212   void * jresult ;
23213   Dali::Vector4 *result = 0 ;
23214
23215   result = (Dali::Vector4 *)&Dali::Color::RED;
23216   jresult = (void *)result;
23217   return jresult;
23218 }
23219
23220
23221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23222   void * jresult ;
23223   Dali::Vector4 *result = 0 ;
23224
23225   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23226   jresult = (void *)result;
23227   return jresult;
23228 }
23229
23230
23231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23232   void * jresult ;
23233   Dali::Vector4 *result = 0 ;
23234
23235   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23236   jresult = (void *)result;
23237   return jresult;
23238 }
23239
23240
23241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23242   void * jresult ;
23243   Dali::Vector4 *result = 0 ;
23244
23245   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23246   jresult = (void *)result;
23247   return jresult;
23248 }
23249
23250
23251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23252   void * jresult ;
23253   Dali::Vector4 *result = 0 ;
23254
23255   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23256   jresult = (void *)result;
23257   return jresult;
23258 }
23259
23260
23261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23262   void * jresult ;
23263   Dali::Vector4 *result = 0 ;
23264
23265   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23266   jresult = (void *)result;
23267   return jresult;
23268 }
23269
23270
23271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23272   void * jresult ;
23273   Dali::Vector4 *result = 0 ;
23274
23275   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23276   jresult = (void *)result;
23277   return jresult;
23278 }
23279
23280
23281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23282   float jresult ;
23283   float result;
23284
23285   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23286   jresult = result;
23287   return jresult;
23288 }
23289
23290
23291 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23292   float jresult ;
23293   float result;
23294
23295   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23296   jresult = result;
23297   return jresult;
23298 }
23299
23300
23301 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23302   float jresult ;
23303   float result;
23304
23305   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23306   jresult = result;
23307   return jresult;
23308 }
23309
23310
23311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23312   float jresult ;
23313   float result;
23314
23315   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23316   jresult = result;
23317   return jresult;
23318 }
23319
23320
23321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23322   float jresult ;
23323   float result;
23324
23325   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23326   jresult = result;
23327   return jresult;
23328 }
23329
23330
23331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23332   float jresult ;
23333   float result;
23334
23335   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23336   jresult = result;
23337   return jresult;
23338 }
23339
23340
23341 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23342   float jresult ;
23343   float result;
23344
23345   result = (float)(float)Dali::Math::PI;
23346   jresult = result;
23347   return jresult;
23348 }
23349
23350
23351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23352   float jresult ;
23353   float result;
23354
23355   result = (float)(float)Dali::Math::PI_2;
23356   jresult = result;
23357   return jresult;
23358 }
23359
23360
23361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23362   float jresult ;
23363   float result;
23364
23365   result = (float)(float)Dali::Math::PI_4;
23366   jresult = result;
23367   return jresult;
23368 }
23369
23370
23371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23372   float jresult ;
23373   float result;
23374
23375   result = (float)(float)Dali::Math::PI_OVER_180;
23376   jresult = result;
23377   return jresult;
23378 }
23379
23380
23381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23382   float jresult ;
23383   float result;
23384
23385   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23386   jresult = result;
23387   return jresult;
23388 }
23389
23390
23391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23392   int jresult ;
23393   Dali::ResizePolicy::Type result;
23394
23395   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23396   jresult = (int)result;
23397   return jresult;
23398 }
23399
23400
23401 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23402   unsigned long jresult ;
23403   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23404   Dali::VectorBase::SizeType result;
23405
23406   arg1 = (Dali::VectorBase *)jarg1;
23407   {
23408     try {
23409       result = ((Dali::VectorBase const *)arg1)->Count();
23410     } catch (std::out_of_range& e) {
23411       {
23412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23413       };
23414     } catch (std::exception& e) {
23415       {
23416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23417       };
23418     } catch (Dali::DaliException e) {
23419       {
23420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23421       };
23422     } catch (...) {
23423       {
23424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23425       };
23426     }
23427   }
23428
23429   jresult = (unsigned long)result;
23430   return jresult;
23431 }
23432
23433
23434 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23435   unsigned long jresult ;
23436   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23437   Dali::VectorBase::SizeType result;
23438
23439   arg1 = (Dali::VectorBase *)jarg1;
23440   {
23441     try {
23442       result = ((Dali::VectorBase const *)arg1)->Size();
23443     } catch (std::out_of_range& e) {
23444       {
23445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23446       };
23447     } catch (std::exception& e) {
23448       {
23449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23450       };
23451     } catch (Dali::DaliException e) {
23452       {
23453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23454       };
23455     } catch (...) {
23456       {
23457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23458       };
23459     }
23460   }
23461
23462   jresult = (unsigned long)result;
23463   return jresult;
23464 }
23465
23466
23467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23468   unsigned int jresult ;
23469   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23470   bool result;
23471
23472   arg1 = (Dali::VectorBase *)jarg1;
23473   {
23474     try {
23475       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23476     } catch (std::out_of_range& e) {
23477       {
23478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23479       };
23480     } catch (std::exception& e) {
23481       {
23482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23483       };
23484     } catch (Dali::DaliException e) {
23485       {
23486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23487       };
23488     } catch (...) {
23489       {
23490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23491       };
23492     }
23493   }
23494
23495   jresult = result;
23496   return jresult;
23497 }
23498
23499
23500 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23501   unsigned long jresult ;
23502   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23503   Dali::VectorBase::SizeType result;
23504
23505   arg1 = (Dali::VectorBase *)jarg1;
23506   {
23507     try {
23508       result = ((Dali::VectorBase const *)arg1)->Capacity();
23509     } catch (std::out_of_range& e) {
23510       {
23511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23512       };
23513     } catch (std::exception& e) {
23514       {
23515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23516       };
23517     } catch (Dali::DaliException e) {
23518       {
23519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23520       };
23521     } catch (...) {
23522       {
23523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23524       };
23525     }
23526   }
23527
23528   jresult = (unsigned long)result;
23529   return jresult;
23530 }
23531
23532
23533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23534   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23535
23536   arg1 = (Dali::VectorBase *)jarg1;
23537   {
23538     try {
23539       (arg1)->Release();
23540     } catch (std::out_of_range& e) {
23541       {
23542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23543       };
23544     } catch (std::exception& e) {
23545       {
23546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23547       };
23548     } catch (Dali::DaliException e) {
23549       {
23550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23551       };
23552     } catch (...) {
23553       {
23554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23555       };
23556     }
23557   }
23558
23559 }
23560
23561
23562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23563   void * jresult ;
23564   Dali::Image *result = 0 ;
23565
23566   {
23567     try {
23568       result = (Dali::Image *)new Dali::Image();
23569     } catch (std::out_of_range& e) {
23570       {
23571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23572       };
23573     } catch (std::exception& e) {
23574       {
23575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23576       };
23577     } catch (Dali::DaliException e) {
23578       {
23579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23580       };
23581     } catch (...) {
23582       {
23583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23584       };
23585     }
23586   }
23587
23588   jresult = (void *)result;
23589   return jresult;
23590 }
23591
23592
23593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23594   Dali::Image *arg1 = (Dali::Image *) 0 ;
23595
23596   arg1 = (Dali::Image *)jarg1;
23597   {
23598     try {
23599       delete arg1;
23600     } catch (std::out_of_range& e) {
23601       {
23602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23603       };
23604     } catch (std::exception& e) {
23605       {
23606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23607       };
23608     } catch (Dali::DaliException e) {
23609       {
23610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23611       };
23612     } catch (...) {
23613       {
23614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23615       };
23616     }
23617   }
23618
23619 }
23620
23621
23622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23623   void * jresult ;
23624   Dali::Image *arg1 = 0 ;
23625   Dali::Image *result = 0 ;
23626
23627   arg1 = (Dali::Image *)jarg1;
23628   if (!arg1) {
23629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23630     return 0;
23631   }
23632   {
23633     try {
23634       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23635     } catch (std::out_of_range& e) {
23636       {
23637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23638       };
23639     } catch (std::exception& e) {
23640       {
23641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23642       };
23643     } catch (Dali::DaliException e) {
23644       {
23645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23646       };
23647     } catch (...) {
23648       {
23649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23650       };
23651     }
23652   }
23653
23654   jresult = (void *)result;
23655   return jresult;
23656 }
23657
23658
23659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23660   void * jresult ;
23661   Dali::Image *arg1 = (Dali::Image *) 0 ;
23662   Dali::Image *arg2 = 0 ;
23663   Dali::Image *result = 0 ;
23664
23665   arg1 = (Dali::Image *)jarg1;
23666   arg2 = (Dali::Image *)jarg2;
23667   if (!arg2) {
23668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23669     return 0;
23670   }
23671   {
23672     try {
23673       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23674     } catch (std::out_of_range& e) {
23675       {
23676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23677       };
23678     } catch (std::exception& e) {
23679       {
23680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23681       };
23682     } catch (Dali::DaliException e) {
23683       {
23684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23685       };
23686     } catch (...) {
23687       {
23688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23689       };
23690     }
23691   }
23692
23693   jresult = (void *)result;
23694   return jresult;
23695 }
23696
23697
23698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23699   void * jresult ;
23700   Dali::BaseHandle arg1 ;
23701   Dali::BaseHandle *argp1 ;
23702   Dali::Image result;
23703
23704   argp1 = (Dali::BaseHandle *)jarg1;
23705   if (!argp1) {
23706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23707     return 0;
23708   }
23709   arg1 = *argp1;
23710   {
23711     try {
23712       result = Dali::Image::DownCast(arg1);
23713     } catch (std::out_of_range& e) {
23714       {
23715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23716       };
23717     } catch (std::exception& e) {
23718       {
23719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23720       };
23721     } catch (Dali::DaliException e) {
23722       {
23723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23724       };
23725     } catch (...) {
23726       {
23727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23728       };
23729     }
23730   }
23731
23732   jresult = new Dali::Image((const Dali::Image &)result);
23733   return jresult;
23734 }
23735
23736
23737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23738   unsigned int jresult ;
23739   Dali::Image *arg1 = (Dali::Image *) 0 ;
23740   unsigned int result;
23741
23742   arg1 = (Dali::Image *)jarg1;
23743   {
23744     try {
23745       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23746     } catch (std::out_of_range& e) {
23747       {
23748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23749       };
23750     } catch (std::exception& e) {
23751       {
23752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23753       };
23754     } catch (Dali::DaliException e) {
23755       {
23756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23757       };
23758     } catch (...) {
23759       {
23760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23761       };
23762     }
23763   }
23764
23765   jresult = result;
23766   return jresult;
23767 }
23768
23769
23770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23771   unsigned int jresult ;
23772   Dali::Image *arg1 = (Dali::Image *) 0 ;
23773   unsigned int result;
23774
23775   arg1 = (Dali::Image *)jarg1;
23776   {
23777     try {
23778       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23779     } catch (std::out_of_range& e) {
23780       {
23781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23782       };
23783     } catch (std::exception& e) {
23784       {
23785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23786       };
23787     } catch (Dali::DaliException e) {
23788       {
23789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23790       };
23791     } catch (...) {
23792       {
23793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23794       };
23795     }
23796   }
23797
23798   jresult = result;
23799   return jresult;
23800 }
23801
23802
23803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23804   void * jresult ;
23805   Dali::Image *arg1 = (Dali::Image *) 0 ;
23806   Dali::Image::ImageSignalType *result = 0 ;
23807
23808   arg1 = (Dali::Image *)jarg1;
23809   {
23810     try {
23811       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23812     } catch (std::out_of_range& e) {
23813       {
23814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23815       };
23816     } catch (std::exception& e) {
23817       {
23818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23819       };
23820     } catch (Dali::DaliException e) {
23821       {
23822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23823       };
23824     } catch (...) {
23825       {
23826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23827       };
23828     }
23829   }
23830
23831   jresult = (void *)result;
23832   return jresult;
23833 }
23834
23835
23836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23837   int jresult ;
23838   Dali::Pixel::Format result;
23839
23840   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23841   jresult = (int)result;
23842   return jresult;
23843 }
23844
23845
23846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23847   int jresult ;
23848   Dali::Pixel::Format result;
23849
23850   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23851   jresult = (int)result;
23852   return jresult;
23853 }
23854
23855
23856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23857   unsigned int jresult ;
23858   Dali::Pixel::Format arg1 ;
23859   bool result;
23860
23861   arg1 = (Dali::Pixel::Format)jarg1;
23862   {
23863     try {
23864       result = (bool)Dali::Pixel::HasAlpha(arg1);
23865     } catch (std::out_of_range& e) {
23866       {
23867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23868       };
23869     } catch (std::exception& e) {
23870       {
23871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23872       };
23873     } catch (Dali::DaliException e) {
23874       {
23875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23876       };
23877     } catch (...) {
23878       {
23879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23880       };
23881     }
23882   }
23883
23884   jresult = result;
23885   return jresult;
23886 }
23887
23888
23889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23890   unsigned int jresult ;
23891   Dali::Pixel::Format arg1 ;
23892   unsigned int result;
23893
23894   arg1 = (Dali::Pixel::Format)jarg1;
23895   {
23896     try {
23897       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23898     } catch (std::out_of_range& e) {
23899       {
23900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23901       };
23902     } catch (std::exception& e) {
23903       {
23904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23905       };
23906     } catch (Dali::DaliException e) {
23907       {
23908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23909       };
23910     } catch (...) {
23911       {
23912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23913       };
23914     }
23915   }
23916
23917   jresult = result;
23918   return jresult;
23919 }
23920
23921
23922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23923   Dali::Pixel::Format arg1 ;
23924   int *arg2 = 0 ;
23925   int *arg3 = 0 ;
23926
23927   arg1 = (Dali::Pixel::Format)jarg1;
23928   arg2 = (int *)jarg2;
23929   if (!arg2) {
23930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23931     return ;
23932   }
23933   arg3 = (int *)jarg3;
23934   if (!arg3) {
23935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23936     return ;
23937   }
23938   {
23939     try {
23940       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23941     } catch (std::out_of_range& e) {
23942       {
23943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23944       };
23945     } catch (std::exception& e) {
23946       {
23947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23948       };
23949     } catch (Dali::DaliException e) {
23950       {
23951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23952       };
23953     } catch (...) {
23954       {
23955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23956       };
23957     }
23958   }
23959
23960 }
23961
23962
23963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23964   void * jresult ;
23965   unsigned char *arg1 = (unsigned char *) 0 ;
23966   unsigned int arg2 ;
23967   unsigned int arg3 ;
23968   unsigned int arg4 ;
23969   Dali::Pixel::Format arg5 ;
23970   Dali::PixelData::ReleaseFunction arg6 ;
23971   Dali::PixelData result;
23972
23973   arg1 = jarg1;
23974   arg2 = (unsigned int)jarg2;
23975   arg3 = (unsigned int)jarg3;
23976   arg4 = (unsigned int)jarg4;
23977   arg5 = (Dali::Pixel::Format)jarg5;
23978   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23979   {
23980     try {
23981       auto pixelBuffer = new unsigned char[jarg2];
23982       memcpy( pixelBuffer, arg1, arg2);
23983       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23984     } catch (std::out_of_range& e) {
23985       {
23986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (std::exception& e) {
23989       {
23990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23991       };
23992     } catch (Dali::DaliException e) {
23993       {
23994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23995       };
23996     } catch (...) {
23997       {
23998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23999       };
24000     }
24001   }
24002
24003   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24004
24005
24006   return jresult;
24007 }
24008
24009
24010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24011   void * jresult ;
24012   Dali::PixelData *result = 0 ;
24013
24014   {
24015     try {
24016       result = (Dali::PixelData *)new Dali::PixelData();
24017     } catch (std::out_of_range& e) {
24018       {
24019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24020       };
24021     } catch (std::exception& e) {
24022       {
24023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24024       };
24025     } catch (Dali::DaliException e) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24028       };
24029     } catch (...) {
24030       {
24031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24032       };
24033     }
24034   }
24035
24036   jresult = (void *)result;
24037   return jresult;
24038 }
24039
24040
24041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24042   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24043
24044   arg1 = (Dali::PixelData *)jarg1;
24045   {
24046     try {
24047       delete arg1;
24048     } catch (std::out_of_range& e) {
24049       {
24050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24051       };
24052     } catch (std::exception& e) {
24053       {
24054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24055       };
24056     } catch (Dali::DaliException e) {
24057       {
24058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24059       };
24060     } catch (...) {
24061       {
24062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24063       };
24064     }
24065   }
24066
24067 }
24068
24069
24070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24071   void * jresult ;
24072   Dali::PixelData *arg1 = 0 ;
24073   Dali::PixelData *result = 0 ;
24074
24075   arg1 = (Dali::PixelData *)jarg1;
24076   if (!arg1) {
24077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24078     return 0;
24079   }
24080   {
24081     try {
24082       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24083     } catch (std::out_of_range& e) {
24084       {
24085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24086       };
24087     } catch (std::exception& e) {
24088       {
24089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24090       };
24091     } catch (Dali::DaliException e) {
24092       {
24093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24094       };
24095     } catch (...) {
24096       {
24097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24098       };
24099     }
24100   }
24101
24102   jresult = (void *)result;
24103   return jresult;
24104 }
24105
24106
24107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24108   void * jresult ;
24109   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24110   Dali::PixelData *arg2 = 0 ;
24111   Dali::PixelData *result = 0 ;
24112
24113   arg1 = (Dali::PixelData *)jarg1;
24114   arg2 = (Dali::PixelData *)jarg2;
24115   if (!arg2) {
24116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24117     return 0;
24118   }
24119   {
24120     try {
24121       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24122     } catch (std::out_of_range& e) {
24123       {
24124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24125       };
24126     } catch (std::exception& e) {
24127       {
24128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24129       };
24130     } catch (Dali::DaliException e) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24133       };
24134     } catch (...) {
24135       {
24136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24137       };
24138     }
24139   }
24140
24141   jresult = (void *)result;
24142   return jresult;
24143 }
24144
24145
24146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24147   unsigned int jresult ;
24148   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24149   unsigned int result;
24150
24151   arg1 = (Dali::PixelData *)jarg1;
24152   {
24153     try {
24154       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24155     } catch (std::out_of_range& e) {
24156       {
24157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24158       };
24159     } catch (std::exception& e) {
24160       {
24161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24162       };
24163     } catch (Dali::DaliException e) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24166       };
24167     } catch (...) {
24168       {
24169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24170       };
24171     }
24172   }
24173
24174   jresult = result;
24175   return jresult;
24176 }
24177
24178
24179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24180   unsigned int jresult ;
24181   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24182   unsigned int result;
24183
24184   arg1 = (Dali::PixelData *)jarg1;
24185   {
24186     try {
24187       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24188     } catch (std::out_of_range& e) {
24189       {
24190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24191       };
24192     } catch (std::exception& e) {
24193       {
24194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24195       };
24196     } catch (Dali::DaliException e) {
24197       {
24198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24199       };
24200     } catch (...) {
24201       {
24202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24203       };
24204     }
24205   }
24206
24207   jresult = result;
24208   return jresult;
24209 }
24210
24211
24212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24213   int jresult ;
24214   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24215   Dali::Pixel::Format result;
24216
24217   arg1 = (Dali::PixelData *)jarg1;
24218   {
24219     try {
24220       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24221     } catch (std::out_of_range& e) {
24222       {
24223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24224       };
24225     } catch (std::exception& e) {
24226       {
24227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24228       };
24229     } catch (Dali::DaliException e) {
24230       {
24231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24232       };
24233     } catch (...) {
24234       {
24235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24236       };
24237     }
24238   }
24239
24240   jresult = (int)result;
24241   return jresult;
24242 }
24243
24244
24245 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24246   unsigned int jresult ;
24247   unsigned int result;
24248
24249   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24250   jresult = result;
24251   return jresult;
24252 }
24253
24254
24255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24256   unsigned int jresult ;
24257   unsigned int result;
24258
24259   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24260   jresult = result;
24261   return jresult;
24262 }
24263
24264
24265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24266   unsigned int jresult ;
24267   unsigned int result;
24268
24269   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24270   jresult = result;
24271   return jresult;
24272 }
24273
24274
24275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24276   unsigned int jresult ;
24277   unsigned int result;
24278
24279   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24280   jresult = result;
24281   return jresult;
24282 }
24283
24284
24285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24286   unsigned int jresult ;
24287   unsigned int result;
24288
24289   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24290   jresult = result;
24291   return jresult;
24292 }
24293
24294
24295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24296   unsigned int jresult ;
24297   unsigned int result;
24298
24299   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24300   jresult = result;
24301   return jresult;
24302 }
24303
24304
24305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24306   void * jresult ;
24307   Dali::TextureType::Type arg1 ;
24308   Dali::Pixel::Format arg2 ;
24309   unsigned int arg3 ;
24310   unsigned int arg4 ;
24311   Dali::Texture result;
24312
24313   arg1 = (Dali::TextureType::Type)jarg1;
24314   arg2 = (Dali::Pixel::Format)jarg2;
24315   arg3 = (unsigned int)jarg3;
24316   arg4 = (unsigned int)jarg4;
24317   {
24318     try {
24319       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24320     } catch (std::out_of_range& e) {
24321       {
24322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24323       };
24324     } catch (std::exception& e) {
24325       {
24326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24327       };
24328     } catch (Dali::DaliException e) {
24329       {
24330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24331       };
24332     } catch (...) {
24333       {
24334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24335       };
24336     }
24337   }
24338
24339   jresult = new Dali::Texture((const Dali::Texture &)result);
24340   return jresult;
24341 }
24342
24343
24344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24345   void * jresult ;
24346   NativeImageInterface *arg1 = 0 ;
24347   Dali::Texture result;
24348
24349   arg1 = (NativeImageInterface *)jarg1;
24350   if (!arg1) {
24351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24352     return 0;
24353   }
24354   {
24355     try {
24356       result = Dali::Texture::New(*arg1);
24357     } catch (std::out_of_range& e) {
24358       {
24359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24360       };
24361     } catch (std::exception& e) {
24362       {
24363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24364       };
24365     } catch (Dali::DaliException e) {
24366       {
24367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24368       };
24369     } catch (...) {
24370       {
24371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24372       };
24373     }
24374   }
24375
24376   jresult = new Dali::Texture((const Dali::Texture &)result);
24377   return jresult;
24378 }
24379
24380
24381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24382   void * jresult ;
24383   Dali::Texture *result = 0 ;
24384
24385   {
24386     try {
24387       result = (Dali::Texture *)new Dali::Texture();
24388     } catch (std::out_of_range& e) {
24389       {
24390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24391       };
24392     } catch (std::exception& e) {
24393       {
24394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24395       };
24396     } catch (Dali::DaliException e) {
24397       {
24398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24399       };
24400     } catch (...) {
24401       {
24402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24403       };
24404     }
24405   }
24406
24407   jresult = (void *)result;
24408   return jresult;
24409 }
24410
24411
24412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24413   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24414
24415   arg1 = (Dali::Texture *)jarg1;
24416   {
24417     try {
24418       delete arg1;
24419     } catch (std::out_of_range& e) {
24420       {
24421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24422       };
24423     } catch (std::exception& e) {
24424       {
24425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24426       };
24427     } catch (Dali::DaliException e) {
24428       {
24429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24430       };
24431     } catch (...) {
24432       {
24433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24434       };
24435     }
24436   }
24437
24438 }
24439
24440
24441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24442   void * jresult ;
24443   Dali::Texture *arg1 = 0 ;
24444   Dali::Texture *result = 0 ;
24445
24446   arg1 = (Dali::Texture *)jarg1;
24447   if (!arg1) {
24448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24449     return 0;
24450   }
24451   {
24452     try {
24453       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24454     } catch (std::out_of_range& e) {
24455       {
24456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24457       };
24458     } catch (std::exception& e) {
24459       {
24460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24461       };
24462     } catch (Dali::DaliException e) {
24463       {
24464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24465       };
24466     } catch (...) {
24467       {
24468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24469       };
24470     }
24471   }
24472
24473   jresult = (void *)result;
24474   return jresult;
24475 }
24476
24477
24478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24479   void * jresult ;
24480   Dali::BaseHandle arg1 ;
24481   Dali::BaseHandle *argp1 ;
24482   Dali::Texture result;
24483
24484   argp1 = (Dali::BaseHandle *)jarg1;
24485   if (!argp1) {
24486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24487     return 0;
24488   }
24489   arg1 = *argp1;
24490   {
24491     try {
24492       result = Dali::Texture::DownCast(arg1);
24493     } catch (std::out_of_range& e) {
24494       {
24495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24496       };
24497     } catch (std::exception& e) {
24498       {
24499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24500       };
24501     } catch (Dali::DaliException e) {
24502       {
24503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24504       };
24505     } catch (...) {
24506       {
24507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24508       };
24509     }
24510   }
24511
24512   jresult = new Dali::Texture((const Dali::Texture &)result);
24513   return jresult;
24514 }
24515
24516
24517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24518   void * jresult ;
24519   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24520   Dali::Texture *arg2 = 0 ;
24521   Dali::Texture *result = 0 ;
24522
24523   arg1 = (Dali::Texture *)jarg1;
24524   arg2 = (Dali::Texture *)jarg2;
24525   if (!arg2) {
24526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24527     return 0;
24528   }
24529   {
24530     try {
24531       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
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 = (void *)result;
24552   return jresult;
24553 }
24554
24555
24556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24557   unsigned int jresult ;
24558   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24559   Dali::PixelData arg2 ;
24560   Dali::PixelData *argp2 ;
24561   bool result;
24562
24563   arg1 = (Dali::Texture *)jarg1;
24564   argp2 = (Dali::PixelData *)jarg2;
24565   if (!argp2) {
24566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24567     return 0;
24568   }
24569   arg2 = *argp2;
24570   {
24571     try {
24572       result = (bool)(arg1)->Upload(arg2);
24573     } catch (std::out_of_range& e) {
24574       {
24575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24576       };
24577     } catch (std::exception& e) {
24578       {
24579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24580       };
24581     } catch (Dali::DaliException e) {
24582       {
24583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24584       };
24585     } catch (...) {
24586       {
24587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24588       };
24589     }
24590   }
24591
24592   jresult = result;
24593   return jresult;
24594 }
24595
24596
24597 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) {
24598   unsigned int jresult ;
24599   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24600   Dali::PixelData arg2 ;
24601   unsigned int arg3 ;
24602   unsigned int arg4 ;
24603   unsigned int arg5 ;
24604   unsigned int arg6 ;
24605   unsigned int arg7 ;
24606   unsigned int arg8 ;
24607   Dali::PixelData *argp2 ;
24608   bool result;
24609
24610   arg1 = (Dali::Texture *)jarg1;
24611   argp2 = (Dali::PixelData *)jarg2;
24612   if (!argp2) {
24613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24614     return 0;
24615   }
24616   arg2 = *argp2;
24617   arg3 = (unsigned int)jarg3;
24618   arg4 = (unsigned int)jarg4;
24619   arg5 = (unsigned int)jarg5;
24620   arg6 = (unsigned int)jarg6;
24621   arg7 = (unsigned int)jarg7;
24622   arg8 = (unsigned int)jarg8;
24623   {
24624     try {
24625       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24626     } catch (std::out_of_range& e) {
24627       {
24628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24629       };
24630     } catch (std::exception& e) {
24631       {
24632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24633       };
24634     } catch (Dali::DaliException e) {
24635       {
24636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24637       };
24638     } catch (...) {
24639       {
24640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24641       };
24642     }
24643   }
24644
24645   jresult = result;
24646   return jresult;
24647 }
24648
24649
24650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24651   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24652
24653   arg1 = (Dali::Texture *)jarg1;
24654   {
24655     try {
24656       (arg1)->GenerateMipmaps();
24657     } catch (std::out_of_range& e) {
24658       {
24659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24660       };
24661     } catch (std::exception& e) {
24662       {
24663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24664       };
24665     } catch (Dali::DaliException e) {
24666       {
24667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24668       };
24669     } catch (...) {
24670       {
24671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24672       };
24673     }
24674   }
24675
24676 }
24677
24678
24679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24680   unsigned int jresult ;
24681   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24682   unsigned int result;
24683
24684   arg1 = (Dali::Texture *)jarg1;
24685   {
24686     try {
24687       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24688     } catch (std::out_of_range& e) {
24689       {
24690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24691       };
24692     } catch (std::exception& e) {
24693       {
24694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24695       };
24696     } catch (Dali::DaliException e) {
24697       {
24698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24699       };
24700     } catch (...) {
24701       {
24702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24703       };
24704     }
24705   }
24706
24707   jresult = result;
24708   return jresult;
24709 }
24710
24711
24712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24713   unsigned int jresult ;
24714   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24715   unsigned int result;
24716
24717   arg1 = (Dali::Texture *)jarg1;
24718   {
24719     try {
24720       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24721     } catch (std::out_of_range& e) {
24722       {
24723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24724       };
24725     } catch (std::exception& e) {
24726       {
24727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24728       };
24729     } catch (Dali::DaliException e) {
24730       {
24731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24732       };
24733     } catch (...) {
24734       {
24735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24736       };
24737     }
24738   }
24739
24740   jresult = result;
24741   return jresult;
24742 }
24743
24744
24745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24746   void * jresult ;
24747   Dali::Sampler result;
24748
24749   {
24750     try {
24751       result = Dali::Sampler::New();
24752     } catch (std::out_of_range& e) {
24753       {
24754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24755       };
24756     } catch (std::exception& e) {
24757       {
24758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24759       };
24760     } catch (Dali::DaliException e) {
24761       {
24762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24763       };
24764     } catch (...) {
24765       {
24766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24767       };
24768     }
24769   }
24770
24771   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24772   return jresult;
24773 }
24774
24775
24776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24777   void * jresult ;
24778   Dali::Sampler *result = 0 ;
24779
24780   {
24781     try {
24782       result = (Dali::Sampler *)new Dali::Sampler();
24783     } catch (std::out_of_range& e) {
24784       {
24785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24786       };
24787     } catch (std::exception& e) {
24788       {
24789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24790       };
24791     } catch (Dali::DaliException e) {
24792       {
24793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24794       };
24795     } catch (...) {
24796       {
24797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24798       };
24799     }
24800   }
24801
24802   jresult = (void *)result;
24803   return jresult;
24804 }
24805
24806
24807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24808   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24809
24810   arg1 = (Dali::Sampler *)jarg1;
24811   {
24812     try {
24813       delete arg1;
24814     } catch (std::out_of_range& e) {
24815       {
24816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24817       };
24818     } catch (std::exception& e) {
24819       {
24820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24821       };
24822     } catch (Dali::DaliException e) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24825       };
24826     } catch (...) {
24827       {
24828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24829       };
24830     }
24831   }
24832
24833 }
24834
24835
24836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24837   void * jresult ;
24838   Dali::Sampler *arg1 = 0 ;
24839   Dali::Sampler *result = 0 ;
24840
24841   arg1 = (Dali::Sampler *)jarg1;
24842   if (!arg1) {
24843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24844     return 0;
24845   }
24846   {
24847     try {
24848       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24849     } catch (std::out_of_range& e) {
24850       {
24851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24852       };
24853     } catch (std::exception& e) {
24854       {
24855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24856       };
24857     } catch (Dali::DaliException e) {
24858       {
24859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24860       };
24861     } catch (...) {
24862       {
24863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24864       };
24865     }
24866   }
24867
24868   jresult = (void *)result;
24869   return jresult;
24870 }
24871
24872
24873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24874   void * jresult ;
24875   Dali::BaseHandle arg1 ;
24876   Dali::BaseHandle *argp1 ;
24877   Dali::Sampler result;
24878
24879   argp1 = (Dali::BaseHandle *)jarg1;
24880   if (!argp1) {
24881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24882     return 0;
24883   }
24884   arg1 = *argp1;
24885   {
24886     try {
24887       result = Dali::Sampler::DownCast(arg1);
24888     } catch (std::out_of_range& e) {
24889       {
24890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24891       };
24892     } catch (std::exception& e) {
24893       {
24894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24895       };
24896     } catch (Dali::DaliException e) {
24897       {
24898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24899       };
24900     } catch (...) {
24901       {
24902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24903       };
24904     }
24905   }
24906
24907   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24908   return jresult;
24909 }
24910
24911
24912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24913   void * jresult ;
24914   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24915   Dali::Sampler *arg2 = 0 ;
24916   Dali::Sampler *result = 0 ;
24917
24918   arg1 = (Dali::Sampler *)jarg1;
24919   arg2 = (Dali::Sampler *)jarg2;
24920   if (!arg2) {
24921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24922     return 0;
24923   }
24924   {
24925     try {
24926       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24927     } catch (std::out_of_range& e) {
24928       {
24929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24930       };
24931     } catch (std::exception& e) {
24932       {
24933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24934       };
24935     } catch (Dali::DaliException e) {
24936       {
24937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24938       };
24939     } catch (...) {
24940       {
24941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24942       };
24943     }
24944   }
24945
24946   jresult = (void *)result;
24947   return jresult;
24948 }
24949
24950
24951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24952   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24953   Dali::FilterMode::Type arg2 ;
24954   Dali::FilterMode::Type arg3 ;
24955
24956   arg1 = (Dali::Sampler *)jarg1;
24957   arg2 = (Dali::FilterMode::Type)jarg2;
24958   arg3 = (Dali::FilterMode::Type)jarg3;
24959   {
24960     try {
24961       (arg1)->SetFilterMode(arg2,arg3);
24962     } catch (std::out_of_range& e) {
24963       {
24964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24965       };
24966     } catch (std::exception& e) {
24967       {
24968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24969       };
24970     } catch (Dali::DaliException e) {
24971       {
24972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24973       };
24974     } catch (...) {
24975       {
24976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24977       };
24978     }
24979   }
24980
24981 }
24982
24983
24984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24985   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24986   Dali::WrapMode::Type arg2 ;
24987   Dali::WrapMode::Type arg3 ;
24988
24989   arg1 = (Dali::Sampler *)jarg1;
24990   arg2 = (Dali::WrapMode::Type)jarg2;
24991   arg3 = (Dali::WrapMode::Type)jarg3;
24992   {
24993     try {
24994       (arg1)->SetWrapMode(arg2,arg3);
24995     } catch (std::out_of_range& e) {
24996       {
24997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24998       };
24999     } catch (std::exception& e) {
25000       {
25001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25002       };
25003     } catch (Dali::DaliException e) {
25004       {
25005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25006       };
25007     } catch (...) {
25008       {
25009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25010       };
25011     }
25012   }
25013
25014 }
25015
25016
25017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25018   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25019   Dali::WrapMode::Type arg2 ;
25020   Dali::WrapMode::Type arg3 ;
25021   Dali::WrapMode::Type arg4 ;
25022
25023   arg1 = (Dali::Sampler *)jarg1;
25024   arg2 = (Dali::WrapMode::Type)jarg2;
25025   arg3 = (Dali::WrapMode::Type)jarg3;
25026   arg4 = (Dali::WrapMode::Type)jarg4;
25027   {
25028     try {
25029       (arg1)->SetWrapMode(arg2,arg3,arg4);
25030     } catch (std::out_of_range& e) {
25031       {
25032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25033       };
25034     } catch (std::exception& e) {
25035       {
25036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25037       };
25038     } catch (Dali::DaliException e) {
25039       {
25040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25041       };
25042     } catch (...) {
25043       {
25044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25045       };
25046     }
25047   }
25048
25049 }
25050
25051
25052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25053   void * jresult ;
25054   Dali::TextureSet result;
25055
25056   {
25057     try {
25058       result = Dali::TextureSet::New();
25059     } catch (std::out_of_range& e) {
25060       {
25061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25062       };
25063     } catch (std::exception& e) {
25064       {
25065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25066       };
25067     } catch (Dali::DaliException e) {
25068       {
25069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25070       };
25071     } catch (...) {
25072       {
25073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25074       };
25075     }
25076   }
25077
25078   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25079   return jresult;
25080 }
25081
25082
25083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25084   void * jresult ;
25085   Dali::TextureSet *result = 0 ;
25086
25087   {
25088     try {
25089       result = (Dali::TextureSet *)new Dali::TextureSet();
25090     } catch (std::out_of_range& e) {
25091       {
25092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25093       };
25094     } catch (std::exception& e) {
25095       {
25096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25097       };
25098     } catch (Dali::DaliException e) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25101       };
25102     } catch (...) {
25103       {
25104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25105       };
25106     }
25107   }
25108
25109   jresult = (void *)result;
25110   return jresult;
25111 }
25112
25113
25114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25115   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25116
25117   arg1 = (Dali::TextureSet *)jarg1;
25118   {
25119     try {
25120       delete arg1;
25121     } catch (std::out_of_range& e) {
25122       {
25123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25124       };
25125     } catch (std::exception& e) {
25126       {
25127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25128       };
25129     } catch (Dali::DaliException e) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25132       };
25133     } catch (...) {
25134       {
25135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25136       };
25137     }
25138   }
25139
25140 }
25141
25142
25143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25144   void * jresult ;
25145   Dali::TextureSet *arg1 = 0 ;
25146   Dali::TextureSet *result = 0 ;
25147
25148   arg1 = (Dali::TextureSet *)jarg1;
25149   if (!arg1) {
25150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25151     return 0;
25152   }
25153   {
25154     try {
25155       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25156     } catch (std::out_of_range& e) {
25157       {
25158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25159       };
25160     } catch (std::exception& e) {
25161       {
25162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25163       };
25164     } catch (Dali::DaliException e) {
25165       {
25166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25167       };
25168     } catch (...) {
25169       {
25170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25171       };
25172     }
25173   }
25174
25175   jresult = (void *)result;
25176   return jresult;
25177 }
25178
25179
25180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25181   void * jresult ;
25182   Dali::BaseHandle arg1 ;
25183   Dali::BaseHandle *argp1 ;
25184   Dali::TextureSet result;
25185
25186   argp1 = (Dali::BaseHandle *)jarg1;
25187   if (!argp1) {
25188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25189     return 0;
25190   }
25191   arg1 = *argp1;
25192   {
25193     try {
25194       result = Dali::TextureSet::DownCast(arg1);
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 = new Dali::TextureSet((const Dali::TextureSet &)result);
25215   return jresult;
25216 }
25217
25218
25219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25220   void * jresult ;
25221   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25222   Dali::TextureSet *arg2 = 0 ;
25223   Dali::TextureSet *result = 0 ;
25224
25225   arg1 = (Dali::TextureSet *)jarg1;
25226   arg2 = (Dali::TextureSet *)jarg2;
25227   if (!arg2) {
25228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25229     return 0;
25230   }
25231   {
25232     try {
25233       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25234     } catch (std::out_of_range& e) {
25235       {
25236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25237       };
25238     } catch (std::exception& e) {
25239       {
25240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25241       };
25242     } catch (Dali::DaliException e) {
25243       {
25244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25245       };
25246     } catch (...) {
25247       {
25248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25249       };
25250     }
25251   }
25252
25253   jresult = (void *)result;
25254   return jresult;
25255 }
25256
25257
25258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25259   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25260   size_t arg2 ;
25261   Dali::Texture arg3 ;
25262   Dali::Texture *argp3 ;
25263
25264   arg1 = (Dali::TextureSet *)jarg1;
25265   arg2 = (size_t)jarg2;
25266   argp3 = (Dali::Texture *)jarg3;
25267   if (!argp3) {
25268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25269     return ;
25270   }
25271   arg3 = *argp3;
25272   {
25273     try {
25274       (arg1)->SetTexture(arg2,arg3);
25275     } catch (std::out_of_range& e) {
25276       {
25277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (std::exception& e) {
25280       {
25281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25282       };
25283     } catch (Dali::DaliException e) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25286       };
25287     } catch (...) {
25288       {
25289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25290       };
25291     }
25292   }
25293
25294 }
25295
25296
25297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25298   void * jresult ;
25299   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25300   size_t arg2 ;
25301   Dali::Texture result;
25302
25303   arg1 = (Dali::TextureSet *)jarg1;
25304   arg2 = (size_t)jarg2;
25305   {
25306     try {
25307       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25308     } catch (std::out_of_range& e) {
25309       {
25310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25311       };
25312     } catch (std::exception& e) {
25313       {
25314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25315       };
25316     } catch (Dali::DaliException e) {
25317       {
25318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25319       };
25320     } catch (...) {
25321       {
25322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25323       };
25324     }
25325   }
25326
25327   jresult = new Dali::Texture((const Dali::Texture &)result);
25328   return jresult;
25329 }
25330
25331
25332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25333   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25334   size_t arg2 ;
25335   Dali::Sampler arg3 ;
25336   Dali::Sampler *argp3 ;
25337
25338   arg1 = (Dali::TextureSet *)jarg1;
25339   arg2 = (size_t)jarg2;
25340   argp3 = (Dali::Sampler *)jarg3;
25341   if (!argp3) {
25342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25343     return ;
25344   }
25345   arg3 = *argp3;
25346   {
25347     try {
25348       (arg1)->SetSampler(arg2,arg3);
25349     } catch (std::out_of_range& e) {
25350       {
25351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25352       };
25353     } catch (std::exception& e) {
25354       {
25355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25356       };
25357     } catch (Dali::DaliException e) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25360       };
25361     } catch (...) {
25362       {
25363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25364       };
25365     }
25366   }
25367
25368 }
25369
25370
25371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25372   void * jresult ;
25373   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25374   size_t arg2 ;
25375   Dali::Sampler result;
25376
25377   arg1 = (Dali::TextureSet *)jarg1;
25378   arg2 = (size_t)jarg2;
25379   {
25380     try {
25381       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25382     } catch (std::out_of_range& e) {
25383       {
25384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25385       };
25386     } catch (std::exception& e) {
25387       {
25388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25389       };
25390     } catch (Dali::DaliException e) {
25391       {
25392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25393       };
25394     } catch (...) {
25395       {
25396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25397       };
25398     }
25399   }
25400
25401   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25402   return jresult;
25403 }
25404
25405
25406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25407   unsigned long jresult ;
25408   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25409   size_t result;
25410
25411   arg1 = (Dali::TextureSet *)jarg1;
25412   {
25413     try {
25414       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25415     } catch (std::out_of_range& e) {
25416       {
25417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25418       };
25419     } catch (std::exception& e) {
25420       {
25421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25422       };
25423     } catch (Dali::DaliException e) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25426       };
25427     } catch (...) {
25428       {
25429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25430       };
25431     }
25432   }
25433
25434   jresult = (unsigned long)result;
25435   return jresult;
25436 }
25437
25438
25439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25440   void * jresult ;
25441   Dali::Property::Map *arg1 = 0 ;
25442   Dali::PropertyBuffer result;
25443
25444   arg1 = (Dali::Property::Map *)jarg1;
25445   if (!arg1) {
25446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25447     return 0;
25448   }
25449   {
25450     try {
25451       result = Dali::PropertyBuffer::New(*arg1);
25452     } catch (std::out_of_range& e) {
25453       {
25454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (std::exception& e) {
25457       {
25458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25459       };
25460     } catch (Dali::DaliException e) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25463       };
25464     } catch (...) {
25465       {
25466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25467       };
25468     }
25469   }
25470
25471   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25472   return jresult;
25473 }
25474
25475
25476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25477   void * jresult ;
25478   Dali::PropertyBuffer *result = 0 ;
25479
25480   {
25481     try {
25482       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25483     } catch (std::out_of_range& e) {
25484       {
25485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25486       };
25487     } catch (std::exception& e) {
25488       {
25489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25490       };
25491     } catch (Dali::DaliException e) {
25492       {
25493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25494       };
25495     } catch (...) {
25496       {
25497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25498       };
25499     }
25500   }
25501
25502   jresult = (void *)result;
25503   return jresult;
25504 }
25505
25506
25507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25508   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25509
25510   arg1 = (Dali::PropertyBuffer *)jarg1;
25511   {
25512     try {
25513       delete arg1;
25514     } catch (std::out_of_range& e) {
25515       {
25516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25517       };
25518     } catch (std::exception& e) {
25519       {
25520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25521       };
25522     } catch (Dali::DaliException e) {
25523       {
25524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25525       };
25526     } catch (...) {
25527       {
25528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25529       };
25530     }
25531   }
25532
25533 }
25534
25535
25536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25537   void * jresult ;
25538   Dali::PropertyBuffer *arg1 = 0 ;
25539   Dali::PropertyBuffer *result = 0 ;
25540
25541   arg1 = (Dali::PropertyBuffer *)jarg1;
25542   if (!arg1) {
25543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25544     return 0;
25545   }
25546   {
25547     try {
25548       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25549     } catch (std::out_of_range& e) {
25550       {
25551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25552       };
25553     } catch (std::exception& e) {
25554       {
25555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25556       };
25557     } catch (Dali::DaliException e) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25560       };
25561     } catch (...) {
25562       {
25563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25564       };
25565     }
25566   }
25567
25568   jresult = (void *)result;
25569   return jresult;
25570 }
25571
25572
25573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25574   void * jresult ;
25575   Dali::BaseHandle arg1 ;
25576   Dali::BaseHandle *argp1 ;
25577   Dali::PropertyBuffer result;
25578
25579   argp1 = (Dali::BaseHandle *)jarg1;
25580   if (!argp1) {
25581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25582     return 0;
25583   }
25584   arg1 = *argp1;
25585   {
25586     try {
25587       result = Dali::PropertyBuffer::DownCast(arg1);
25588     } catch (std::out_of_range& e) {
25589       {
25590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25591       };
25592     } catch (std::exception& e) {
25593       {
25594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25595       };
25596     } catch (Dali::DaliException e) {
25597       {
25598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25599       };
25600     } catch (...) {
25601       {
25602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25603       };
25604     }
25605   }
25606
25607   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25608   return jresult;
25609 }
25610
25611
25612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25613   void * jresult ;
25614   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25615   Dali::PropertyBuffer *arg2 = 0 ;
25616   Dali::PropertyBuffer *result = 0 ;
25617
25618   arg1 = (Dali::PropertyBuffer *)jarg1;
25619   arg2 = (Dali::PropertyBuffer *)jarg2;
25620   if (!arg2) {
25621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25622     return 0;
25623   }
25624   {
25625     try {
25626       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25627     } catch (std::out_of_range& e) {
25628       {
25629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25630       };
25631     } catch (std::exception& e) {
25632       {
25633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25634       };
25635     } catch (Dali::DaliException e) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25638       };
25639     } catch (...) {
25640       {
25641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25642       };
25643     }
25644   }
25645
25646   jresult = (void *)result;
25647   return jresult;
25648 }
25649
25650
25651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25652   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25653   void *arg2 = (void *) 0 ;
25654   std::size_t arg3 ;
25655
25656   arg1 = (Dali::PropertyBuffer *)jarg1;
25657   arg2 = jarg2;
25658   arg3 = (std::size_t)jarg3;
25659   {
25660     try {
25661       (arg1)->SetData((void const *)arg2,arg3);
25662     } catch (std::out_of_range& e) {
25663       {
25664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25665       };
25666     } catch (std::exception& e) {
25667       {
25668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25669       };
25670     } catch (Dali::DaliException e) {
25671       {
25672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25673       };
25674     } catch (...) {
25675       {
25676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25677       };
25678     }
25679   }
25680
25681 }
25682
25683
25684 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25685   unsigned long jresult ;
25686   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25687   std::size_t result;
25688
25689   arg1 = (Dali::PropertyBuffer *)jarg1;
25690   {
25691     try {
25692       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25693     } catch (std::out_of_range& e) {
25694       {
25695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25696       };
25697     } catch (std::exception& e) {
25698       {
25699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25700       };
25701     } catch (Dali::DaliException e) {
25702       {
25703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25704       };
25705     } catch (...) {
25706       {
25707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25708       };
25709     }
25710   }
25711
25712   jresult = (unsigned long)result;
25713   return jresult;
25714 }
25715
25716
25717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25718   void * jresult ;
25719   Dali::Geometry result;
25720
25721   {
25722     try {
25723       result = Dali::Geometry::New();
25724     } catch (std::out_of_range& e) {
25725       {
25726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25727       };
25728     } catch (std::exception& e) {
25729       {
25730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25731       };
25732     } catch (Dali::DaliException e) {
25733       {
25734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25735       };
25736     } catch (...) {
25737       {
25738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25739       };
25740     }
25741   }
25742
25743   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25744   return jresult;
25745 }
25746
25747
25748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25749   void * jresult ;
25750   Dali::Geometry *result = 0 ;
25751
25752   {
25753     try {
25754       result = (Dali::Geometry *)new Dali::Geometry();
25755     } catch (std::out_of_range& e) {
25756       {
25757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25758       };
25759     } catch (std::exception& e) {
25760       {
25761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25762       };
25763     } catch (Dali::DaliException e) {
25764       {
25765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25766       };
25767     } catch (...) {
25768       {
25769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25770       };
25771     }
25772   }
25773
25774   jresult = (void *)result;
25775   return jresult;
25776 }
25777
25778
25779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25780   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25781
25782   arg1 = (Dali::Geometry *)jarg1;
25783   {
25784     try {
25785       delete arg1;
25786     } catch (std::out_of_range& e) {
25787       {
25788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25789       };
25790     } catch (std::exception& e) {
25791       {
25792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25793       };
25794     } catch (Dali::DaliException e) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25797       };
25798     } catch (...) {
25799       {
25800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25801       };
25802     }
25803   }
25804
25805 }
25806
25807
25808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25809   void * jresult ;
25810   Dali::Geometry *arg1 = 0 ;
25811   Dali::Geometry *result = 0 ;
25812
25813   arg1 = (Dali::Geometry *)jarg1;
25814   if (!arg1) {
25815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25816     return 0;
25817   }
25818   {
25819     try {
25820       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25821     } catch (std::out_of_range& e) {
25822       {
25823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25824       };
25825     } catch (std::exception& e) {
25826       {
25827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25828       };
25829     } catch (Dali::DaliException e) {
25830       {
25831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25832       };
25833     } catch (...) {
25834       {
25835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25836       };
25837     }
25838   }
25839
25840   jresult = (void *)result;
25841   return jresult;
25842 }
25843
25844
25845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25846   void * jresult ;
25847   Dali::BaseHandle arg1 ;
25848   Dali::BaseHandle *argp1 ;
25849   Dali::Geometry result;
25850
25851   argp1 = (Dali::BaseHandle *)jarg1;
25852   if (!argp1) {
25853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25854     return 0;
25855   }
25856   arg1 = *argp1;
25857   {
25858     try {
25859       result = Dali::Geometry::DownCast(arg1);
25860     } catch (std::out_of_range& e) {
25861       {
25862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25863       };
25864     } catch (std::exception& e) {
25865       {
25866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25867       };
25868     } catch (Dali::DaliException e) {
25869       {
25870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25871       };
25872     } catch (...) {
25873       {
25874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25875       };
25876     }
25877   }
25878
25879   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25880   return jresult;
25881 }
25882
25883
25884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25885   void * jresult ;
25886   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25887   Dali::Geometry *arg2 = 0 ;
25888   Dali::Geometry *result = 0 ;
25889
25890   arg1 = (Dali::Geometry *)jarg1;
25891   arg2 = (Dali::Geometry *)jarg2;
25892   if (!arg2) {
25893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25894     return 0;
25895   }
25896   {
25897     try {
25898       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25899     } catch (std::out_of_range& e) {
25900       {
25901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25902       };
25903     } catch (std::exception& e) {
25904       {
25905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25906       };
25907     } catch (Dali::DaliException e) {
25908       {
25909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25910       };
25911     } catch (...) {
25912       {
25913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25914       };
25915     }
25916   }
25917
25918   jresult = (void *)result;
25919   return jresult;
25920 }
25921
25922
25923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25924   unsigned long jresult ;
25925   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25926   Dali::PropertyBuffer *arg2 = 0 ;
25927   std::size_t result;
25928
25929   arg1 = (Dali::Geometry *)jarg1;
25930   arg2 = (Dali::PropertyBuffer *)jarg2;
25931   if (!arg2) {
25932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25933     return 0;
25934   }
25935   {
25936     try {
25937       result = (arg1)->AddVertexBuffer(*arg2);
25938     } catch (std::out_of_range& e) {
25939       {
25940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25941       };
25942     } catch (std::exception& e) {
25943       {
25944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25945       };
25946     } catch (Dali::DaliException e) {
25947       {
25948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25949       };
25950     } catch (...) {
25951       {
25952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25953       };
25954     }
25955   }
25956
25957   jresult = (unsigned long)result;
25958   return jresult;
25959 }
25960
25961
25962 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25963   unsigned long jresult ;
25964   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25965   std::size_t result;
25966
25967   arg1 = (Dali::Geometry *)jarg1;
25968   {
25969     try {
25970       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25971     } catch (std::out_of_range& e) {
25972       {
25973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25974       };
25975     } catch (std::exception& e) {
25976       {
25977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25978       };
25979     } catch (Dali::DaliException e) {
25980       {
25981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25982       };
25983     } catch (...) {
25984       {
25985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25986       };
25987     }
25988   }
25989
25990   jresult = (unsigned long)result;
25991   return jresult;
25992 }
25993
25994
25995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25996   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25997   std::size_t arg2 ;
25998
25999   arg1 = (Dali::Geometry *)jarg1;
26000   arg2 = (std::size_t)jarg2;
26001   {
26002     try {
26003       (arg1)->RemoveVertexBuffer(arg2);
26004     } catch (std::out_of_range& e) {
26005       {
26006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26007       };
26008     } catch (std::exception& e) {
26009       {
26010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26011       };
26012     } catch (Dali::DaliException e) {
26013       {
26014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26015       };
26016     } catch (...) {
26017       {
26018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26019       };
26020     }
26021   }
26022
26023 }
26024
26025
26026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26027   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26028   unsigned short *arg2 = (unsigned short *) 0 ;
26029   size_t arg3 ;
26030
26031   arg1 = (Dali::Geometry *)jarg1;
26032   arg2 = jarg2;
26033   arg3 = (size_t)jarg3;
26034   {
26035     try {
26036       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26037     } catch (std::out_of_range& e) {
26038       {
26039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26040       };
26041     } catch (std::exception& e) {
26042       {
26043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26044       };
26045     } catch (Dali::DaliException e) {
26046       {
26047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26048       };
26049     } catch (...) {
26050       {
26051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26052       };
26053     }
26054   }
26055
26056
26057
26058 }
26059
26060
26061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26062   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26063   Dali::Geometry::Type arg2 ;
26064
26065   arg1 = (Dali::Geometry *)jarg1;
26066   arg2 = (Dali::Geometry::Type)jarg2;
26067   {
26068     try {
26069       (arg1)->SetType(arg2);
26070     } catch (std::out_of_range& e) {
26071       {
26072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26073       };
26074     } catch (std::exception& e) {
26075       {
26076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26077       };
26078     } catch (Dali::DaliException e) {
26079       {
26080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26081       };
26082     } catch (...) {
26083       {
26084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26085       };
26086     }
26087   }
26088
26089 }
26090
26091
26092 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26093   int jresult ;
26094   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26095   Dali::Geometry::Type result;
26096
26097   arg1 = (Dali::Geometry *)jarg1;
26098   {
26099     try {
26100       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26101     } catch (std::out_of_range& e) {
26102       {
26103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26104       };
26105     } catch (std::exception& e) {
26106       {
26107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26108       };
26109     } catch (Dali::DaliException e) {
26110       {
26111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26112       };
26113     } catch (...) {
26114       {
26115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26116       };
26117     }
26118   }
26119
26120   jresult = (int)result;
26121   return jresult;
26122 }
26123
26124
26125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26126   void * jresult ;
26127   Dali::Shader::Hint *result = 0 ;
26128
26129   {
26130     try {
26131       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26132     } catch (std::out_of_range& e) {
26133       {
26134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26135       };
26136     } catch (std::exception& e) {
26137       {
26138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26139       };
26140     } catch (Dali::DaliException e) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26143       };
26144     } catch (...) {
26145       {
26146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26147       };
26148     }
26149   }
26150
26151   jresult = (void *)result;
26152   return jresult;
26153 }
26154
26155
26156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26157   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26158
26159   arg1 = (Dali::Shader::Hint *)jarg1;
26160   {
26161     try {
26162       delete arg1;
26163     } catch (std::out_of_range& e) {
26164       {
26165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26166       };
26167     } catch (std::exception& e) {
26168       {
26169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26170       };
26171     } catch (Dali::DaliException e) {
26172       {
26173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26174       };
26175     } catch (...) {
26176       {
26177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26178       };
26179     }
26180   }
26181
26182 }
26183
26184
26185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26186   int jresult ;
26187   int result;
26188
26189   result = (int)Dali::Shader::Property::PROGRAM;
26190   jresult = (int)result;
26191   return jresult;
26192 }
26193
26194
26195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26196   void * jresult ;
26197   Dali::Shader::Property *result = 0 ;
26198
26199   {
26200     try {
26201       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26202     } catch (std::out_of_range& e) {
26203       {
26204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (std::exception& e) {
26207       {
26208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26209       };
26210     } catch (Dali::DaliException e) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26213       };
26214     } catch (...) {
26215       {
26216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26217       };
26218     }
26219   }
26220
26221   jresult = (void *)result;
26222   return jresult;
26223 }
26224
26225
26226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26227   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26228
26229   arg1 = (Dali::Shader::Property *)jarg1;
26230   {
26231     try {
26232       delete arg1;
26233     } catch (std::out_of_range& e) {
26234       {
26235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26236       };
26237     } catch (std::exception& e) {
26238       {
26239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26240       };
26241     } catch (Dali::DaliException e) {
26242       {
26243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26244       };
26245     } catch (...) {
26246       {
26247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26248       };
26249     }
26250   }
26251
26252 }
26253
26254
26255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26256   void * jresult ;
26257   std::string *arg1 = 0 ;
26258   std::string *arg2 = 0 ;
26259   Dali::Shader::Hint::Value arg3 ;
26260   Dali::Shader result;
26261
26262   if (!jarg1) {
26263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26264     return 0;
26265   }
26266   std::string arg1_str(jarg1);
26267   arg1 = &arg1_str;
26268   if (!jarg2) {
26269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26270     return 0;
26271   }
26272   std::string arg2_str(jarg2);
26273   arg2 = &arg2_str;
26274   arg3 = (Dali::Shader::Hint::Value)jarg3;
26275   {
26276     try {
26277       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26278     } catch (std::out_of_range& e) {
26279       {
26280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26281       };
26282     } catch (std::exception& e) {
26283       {
26284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26285       };
26286     } catch (Dali::DaliException e) {
26287       {
26288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26289       };
26290     } catch (...) {
26291       {
26292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26293       };
26294     }
26295   }
26296
26297   jresult = new Dali::Shader((const Dali::Shader &)result);
26298
26299   //argout typemap for const std::string&
26300
26301
26302   //argout typemap for const std::string&
26303
26304   return jresult;
26305 }
26306
26307
26308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26309   void * jresult ;
26310   std::string *arg1 = 0 ;
26311   std::string *arg2 = 0 ;
26312   Dali::Shader result;
26313
26314   if (!jarg1) {
26315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26316     return 0;
26317   }
26318   std::string arg1_str(jarg1);
26319   arg1 = &arg1_str;
26320   if (!jarg2) {
26321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26322     return 0;
26323   }
26324   std::string arg2_str(jarg2);
26325   arg2 = &arg2_str;
26326   {
26327     try {
26328       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26329     } catch (std::out_of_range& e) {
26330       {
26331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26332       };
26333     } catch (std::exception& e) {
26334       {
26335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26336       };
26337     } catch (Dali::DaliException e) {
26338       {
26339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26340       };
26341     } catch (...) {
26342       {
26343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26344       };
26345     }
26346   }
26347
26348   jresult = new Dali::Shader((const Dali::Shader &)result);
26349
26350   //argout typemap for const std::string&
26351
26352
26353   //argout typemap for const std::string&
26354
26355   return jresult;
26356 }
26357
26358
26359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26360   void * jresult ;
26361   Dali::Shader *result = 0 ;
26362
26363   {
26364     try {
26365       result = (Dali::Shader *)new Dali::Shader();
26366     } catch (std::out_of_range& e) {
26367       {
26368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26369       };
26370     } catch (std::exception& e) {
26371       {
26372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26373       };
26374     } catch (Dali::DaliException e) {
26375       {
26376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26377       };
26378     } catch (...) {
26379       {
26380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26381       };
26382     }
26383   }
26384
26385   jresult = (void *)result;
26386   return jresult;
26387 }
26388
26389
26390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26391   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26392
26393   arg1 = (Dali::Shader *)jarg1;
26394   {
26395     try {
26396       delete arg1;
26397     } catch (std::out_of_range& e) {
26398       {
26399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26400       };
26401     } catch (std::exception& e) {
26402       {
26403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26404       };
26405     } catch (Dali::DaliException e) {
26406       {
26407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26408       };
26409     } catch (...) {
26410       {
26411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26412       };
26413     }
26414   }
26415
26416 }
26417
26418
26419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26420   void * jresult ;
26421   Dali::Shader *arg1 = 0 ;
26422   Dali::Shader *result = 0 ;
26423
26424   arg1 = (Dali::Shader *)jarg1;
26425   if (!arg1) {
26426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26427     return 0;
26428   }
26429   {
26430     try {
26431       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26432     } catch (std::out_of_range& e) {
26433       {
26434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26435       };
26436     } catch (std::exception& e) {
26437       {
26438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26439       };
26440     } catch (Dali::DaliException e) {
26441       {
26442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26443       };
26444     } catch (...) {
26445       {
26446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26447       };
26448     }
26449   }
26450
26451   jresult = (void *)result;
26452   return jresult;
26453 }
26454
26455
26456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26457   void * jresult ;
26458   Dali::BaseHandle arg1 ;
26459   Dali::BaseHandle *argp1 ;
26460   Dali::Shader result;
26461
26462   argp1 = (Dali::BaseHandle *)jarg1;
26463   if (!argp1) {
26464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26465     return 0;
26466   }
26467   arg1 = *argp1;
26468   {
26469     try {
26470       result = Dali::Shader::DownCast(arg1);
26471     } catch (std::out_of_range& e) {
26472       {
26473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26474       };
26475     } catch (std::exception& e) {
26476       {
26477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26478       };
26479     } catch (Dali::DaliException e) {
26480       {
26481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26482       };
26483     } catch (...) {
26484       {
26485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26486       };
26487     }
26488   }
26489
26490   jresult = new Dali::Shader((const Dali::Shader &)result);
26491   return jresult;
26492 }
26493
26494
26495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26496   void * jresult ;
26497   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26498   Dali::Shader *arg2 = 0 ;
26499   Dali::Shader *result = 0 ;
26500
26501   arg1 = (Dali::Shader *)jarg1;
26502   arg2 = (Dali::Shader *)jarg2;
26503   if (!arg2) {
26504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26505     return 0;
26506   }
26507   {
26508     try {
26509       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26510     } catch (std::out_of_range& e) {
26511       {
26512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26513       };
26514     } catch (std::exception& e) {
26515       {
26516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26517       };
26518     } catch (Dali::DaliException e) {
26519       {
26520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26521       };
26522     } catch (...) {
26523       {
26524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26525       };
26526     }
26527   }
26528
26529   jresult = (void *)result;
26530   return jresult;
26531 }
26532
26533
26534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26535   int jresult ;
26536   int result;
26537
26538   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26539   jresult = (int)result;
26540   return jresult;
26541 }
26542
26543
26544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26545   int jresult ;
26546   int result;
26547
26548   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26549   jresult = (int)result;
26550   return jresult;
26551 }
26552
26553
26554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26555   int jresult ;
26556   int result;
26557
26558   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26559   jresult = (int)result;
26560   return jresult;
26561 }
26562
26563
26564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26565   int jresult ;
26566   int result;
26567
26568   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26569   jresult = (int)result;
26570   return jresult;
26571 }
26572
26573
26574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26575   int jresult ;
26576   int result;
26577
26578   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26579   jresult = (int)result;
26580   return jresult;
26581 }
26582
26583
26584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26585   int jresult ;
26586   int result;
26587
26588   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26589   jresult = (int)result;
26590   return jresult;
26591 }
26592
26593
26594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26595   int jresult ;
26596   int result;
26597
26598   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26599   jresult = (int)result;
26600   return jresult;
26601 }
26602
26603
26604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26605   int jresult ;
26606   int result;
26607
26608   result = (int)Dali::Renderer::Property::BLEND_MODE;
26609   jresult = (int)result;
26610   return jresult;
26611 }
26612
26613
26614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26615   int jresult ;
26616   int result;
26617
26618   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26619   jresult = (int)result;
26620   return jresult;
26621 }
26622
26623
26624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26625   int jresult ;
26626   int result;
26627
26628   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26629   jresult = (int)result;
26630   return jresult;
26631 }
26632
26633
26634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26635   int jresult ;
26636   int result;
26637
26638   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26639   jresult = (int)result;
26640   return jresult;
26641 }
26642
26643
26644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26645   int jresult ;
26646   int result;
26647
26648   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26649   jresult = (int)result;
26650   return jresult;
26651 }
26652
26653
26654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26655   int jresult ;
26656   int result;
26657
26658   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26659   jresult = (int)result;
26660   return jresult;
26661 }
26662
26663
26664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26665   int jresult ;
26666   int result;
26667
26668   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26669   jresult = (int)result;
26670   return jresult;
26671 }
26672
26673
26674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26675   int jresult ;
26676   int result;
26677
26678   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26679   jresult = (int)result;
26680   return jresult;
26681 }
26682
26683
26684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26685   int jresult ;
26686   int result;
26687
26688   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26689   jresult = (int)result;
26690   return jresult;
26691 }
26692
26693
26694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26695   int jresult ;
26696   int result;
26697
26698   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26699   jresult = (int)result;
26700   return jresult;
26701 }
26702
26703
26704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26705   int jresult ;
26706   int result;
26707
26708   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26709   jresult = (int)result;
26710   return jresult;
26711 }
26712
26713
26714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26715   int jresult ;
26716   int result;
26717
26718   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26719   jresult = (int)result;
26720   return jresult;
26721 }
26722
26723
26724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26725   int jresult ;
26726   int result;
26727
26728   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26729   jresult = (int)result;
26730   return jresult;
26731 }
26732
26733
26734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26735   int jresult ;
26736   int result;
26737
26738   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26739   jresult = (int)result;
26740   return jresult;
26741 }
26742
26743
26744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26745   int jresult ;
26746   int result;
26747
26748   result = (int)Dali::Renderer::Property::RENDER_MODE;
26749   jresult = (int)result;
26750   return jresult;
26751 }
26752
26753
26754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26755   int jresult ;
26756   int result;
26757
26758   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26759   jresult = (int)result;
26760   return jresult;
26761 }
26762
26763
26764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26765   int jresult ;
26766   int result;
26767
26768   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26769   jresult = (int)result;
26770   return jresult;
26771 }
26772
26773
26774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26775   int jresult ;
26776   int result;
26777
26778   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26779   jresult = (int)result;
26780   return jresult;
26781 }
26782
26783
26784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26785   int jresult ;
26786   int result;
26787
26788   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26789   jresult = (int)result;
26790   return jresult;
26791 }
26792
26793
26794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26795   int jresult ;
26796   int result;
26797
26798   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26799   jresult = (int)result;
26800   return jresult;
26801 }
26802
26803
26804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26805   int jresult ;
26806   int result;
26807
26808   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26809   jresult = (int)result;
26810   return jresult;
26811 }
26812
26813
26814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26815   int jresult ;
26816   int result;
26817
26818   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26819   jresult = (int)result;
26820   return jresult;
26821 }
26822
26823
26824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26825   void * jresult ;
26826   Dali::Renderer::Property *result = 0 ;
26827
26828   {
26829     try {
26830       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26831     } catch (std::out_of_range& e) {
26832       {
26833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26834       };
26835     } catch (std::exception& e) {
26836       {
26837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26838       };
26839     } catch (Dali::DaliException e) {
26840       {
26841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26842       };
26843     } catch (...) {
26844       {
26845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26846       };
26847     }
26848   }
26849
26850   jresult = (void *)result;
26851   return jresult;
26852 }
26853
26854
26855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26856   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26857
26858   arg1 = (Dali::Renderer::Property *)jarg1;
26859   {
26860     try {
26861       delete arg1;
26862     } catch (std::out_of_range& e) {
26863       {
26864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26865       };
26866     } catch (std::exception& e) {
26867       {
26868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26869       };
26870     } catch (Dali::DaliException e) {
26871       {
26872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26873       };
26874     } catch (...) {
26875       {
26876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26877       };
26878     }
26879   }
26880
26881 }
26882
26883
26884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26885   void * jresult ;
26886   Dali::Geometry *arg1 = 0 ;
26887   Dali::Shader *arg2 = 0 ;
26888   Dali::Renderer result;
26889
26890   arg1 = (Dali::Geometry *)jarg1;
26891   if (!arg1) {
26892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26893     return 0;
26894   }
26895   arg2 = (Dali::Shader *)jarg2;
26896   if (!arg2) {
26897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26898     return 0;
26899   }
26900   {
26901     try {
26902       result = Dali::Renderer::New(*arg1,*arg2);
26903     } catch (std::out_of_range& e) {
26904       {
26905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26906       };
26907     } catch (std::exception& e) {
26908       {
26909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26910       };
26911     } catch (Dali::DaliException e) {
26912       {
26913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26914       };
26915     } catch (...) {
26916       {
26917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26918       };
26919     }
26920   }
26921
26922   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26923   return jresult;
26924 }
26925
26926
26927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26928   void * jresult ;
26929   Dali::Renderer *result = 0 ;
26930
26931   {
26932     try {
26933       result = (Dali::Renderer *)new Dali::Renderer();
26934     } catch (std::out_of_range& e) {
26935       {
26936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26937       };
26938     } catch (std::exception& e) {
26939       {
26940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26941       };
26942     } catch (Dali::DaliException e) {
26943       {
26944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26945       };
26946     } catch (...) {
26947       {
26948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26949       };
26950     }
26951   }
26952
26953   jresult = (void *)result;
26954   return jresult;
26955 }
26956
26957
26958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26959   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26960
26961   arg1 = (Dali::Renderer *)jarg1;
26962   {
26963     try {
26964       delete arg1;
26965     } catch (std::out_of_range& e) {
26966       {
26967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26968       };
26969     } catch (std::exception& e) {
26970       {
26971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26972       };
26973     } catch (Dali::DaliException e) {
26974       {
26975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26976       };
26977     } catch (...) {
26978       {
26979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26980       };
26981     }
26982   }
26983
26984 }
26985
26986
26987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26988   void * jresult ;
26989   Dali::Renderer *arg1 = 0 ;
26990   Dali::Renderer *result = 0 ;
26991
26992   arg1 = (Dali::Renderer *)jarg1;
26993   if (!arg1) {
26994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26995     return 0;
26996   }
26997   {
26998     try {
26999       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27000     } catch (std::out_of_range& e) {
27001       {
27002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27003       };
27004     } catch (std::exception& e) {
27005       {
27006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27007       };
27008     } catch (Dali::DaliException e) {
27009       {
27010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27011       };
27012     } catch (...) {
27013       {
27014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27015       };
27016     }
27017   }
27018
27019   jresult = (void *)result;
27020   return jresult;
27021 }
27022
27023
27024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27025   void * jresult ;
27026   Dali::BaseHandle arg1 ;
27027   Dali::BaseHandle *argp1 ;
27028   Dali::Renderer result;
27029
27030   argp1 = (Dali::BaseHandle *)jarg1;
27031   if (!argp1) {
27032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27033     return 0;
27034   }
27035   arg1 = *argp1;
27036   {
27037     try {
27038       result = Dali::Renderer::DownCast(arg1);
27039     } catch (std::out_of_range& e) {
27040       {
27041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27042       };
27043     } catch (std::exception& e) {
27044       {
27045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27046       };
27047     } catch (Dali::DaliException e) {
27048       {
27049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27050       };
27051     } catch (...) {
27052       {
27053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27054       };
27055     }
27056   }
27057
27058   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27059   return jresult;
27060 }
27061
27062
27063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27064   void * jresult ;
27065   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27066   Dali::Renderer *arg2 = 0 ;
27067   Dali::Renderer *result = 0 ;
27068
27069   arg1 = (Dali::Renderer *)jarg1;
27070   arg2 = (Dali::Renderer *)jarg2;
27071   if (!arg2) {
27072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27073     return 0;
27074   }
27075   {
27076     try {
27077       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27078     } catch (std::out_of_range& e) {
27079       {
27080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27081       };
27082     } catch (std::exception& e) {
27083       {
27084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27085       };
27086     } catch (Dali::DaliException e) {
27087       {
27088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27089       };
27090     } catch (...) {
27091       {
27092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27093       };
27094     }
27095   }
27096
27097   jresult = (void *)result;
27098   return jresult;
27099 }
27100
27101
27102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27103   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27104   Dali::Geometry *arg2 = 0 ;
27105
27106   arg1 = (Dali::Renderer *)jarg1;
27107   arg2 = (Dali::Geometry *)jarg2;
27108   if (!arg2) {
27109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27110     return ;
27111   }
27112   {
27113     try {
27114       (arg1)->SetGeometry(*arg2);
27115     } catch (std::out_of_range& e) {
27116       {
27117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27118       };
27119     } catch (std::exception& e) {
27120       {
27121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27122       };
27123     } catch (Dali::DaliException e) {
27124       {
27125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27126       };
27127     } catch (...) {
27128       {
27129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27130       };
27131     }
27132   }
27133
27134 }
27135
27136
27137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27138   void * jresult ;
27139   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27140   Dali::Geometry result;
27141
27142   arg1 = (Dali::Renderer *)jarg1;
27143   {
27144     try {
27145       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27146     } catch (std::out_of_range& e) {
27147       {
27148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27149       };
27150     } catch (std::exception& e) {
27151       {
27152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27153       };
27154     } catch (Dali::DaliException e) {
27155       {
27156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27157       };
27158     } catch (...) {
27159       {
27160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27161       };
27162     }
27163   }
27164
27165   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27166   return jresult;
27167 }
27168
27169
27170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27171   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27172   int arg2 ;
27173   int arg3 ;
27174
27175   arg1 = (Dali::Renderer *)jarg1;
27176   arg2 = (int)jarg2;
27177   arg3 = (int)jarg3;
27178   {
27179     try {
27180       (arg1)->SetIndexRange(arg2,arg3);
27181     } catch (std::out_of_range& e) {
27182       {
27183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27184       };
27185     } catch (std::exception& e) {
27186       {
27187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27188       };
27189     } catch (Dali::DaliException e) {
27190       {
27191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27192       };
27193     } catch (...) {
27194       {
27195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27196       };
27197     }
27198   }
27199
27200 }
27201
27202
27203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27204   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27205   Dali::TextureSet *arg2 = 0 ;
27206
27207   arg1 = (Dali::Renderer *)jarg1;
27208   arg2 = (Dali::TextureSet *)jarg2;
27209   if (!arg2) {
27210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27211     return ;
27212   }
27213   {
27214     try {
27215       (arg1)->SetTextures(*arg2);
27216     } catch (std::out_of_range& e) {
27217       {
27218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27219       };
27220     } catch (std::exception& e) {
27221       {
27222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27223       };
27224     } catch (Dali::DaliException e) {
27225       {
27226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27227       };
27228     } catch (...) {
27229       {
27230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27231       };
27232     }
27233   }
27234
27235 }
27236
27237
27238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27239   void * jresult ;
27240   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27241   Dali::TextureSet result;
27242
27243   arg1 = (Dali::Renderer *)jarg1;
27244   {
27245     try {
27246       result = ((Dali::Renderer const *)arg1)->GetTextures();
27247     } catch (std::out_of_range& e) {
27248       {
27249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27250       };
27251     } catch (std::exception& e) {
27252       {
27253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27254       };
27255     } catch (Dali::DaliException e) {
27256       {
27257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27258       };
27259     } catch (...) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27262       };
27263     }
27264   }
27265
27266   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27267   return jresult;
27268 }
27269
27270
27271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27272   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27273   Dali::Shader *arg2 = 0 ;
27274
27275   arg1 = (Dali::Renderer *)jarg1;
27276   arg2 = (Dali::Shader *)jarg2;
27277   if (!arg2) {
27278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27279     return ;
27280   }
27281   {
27282     try {
27283       (arg1)->SetShader(*arg2);
27284     } catch (std::out_of_range& e) {
27285       {
27286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27287       };
27288     } catch (std::exception& e) {
27289       {
27290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27291       };
27292     } catch (Dali::DaliException e) {
27293       {
27294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27295       };
27296     } catch (...) {
27297       {
27298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27299       };
27300     }
27301   }
27302
27303 }
27304
27305
27306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27307   void * jresult ;
27308   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27309   Dali::Shader result;
27310
27311   arg1 = (Dali::Renderer *)jarg1;
27312   {
27313     try {
27314       result = ((Dali::Renderer const *)arg1)->GetShader();
27315     } catch (std::out_of_range& e) {
27316       {
27317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27318       };
27319     } catch (std::exception& e) {
27320       {
27321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27322       };
27323     } catch (Dali::DaliException e) {
27324       {
27325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27326       };
27327     } catch (...) {
27328       {
27329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27330       };
27331     }
27332   }
27333
27334   jresult = new Dali::Shader((const Dali::Shader &)result);
27335   return jresult;
27336 }
27337
27338
27339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27340   void * jresult ;
27341   Dali::FrameBuffer::Attachment *result = 0 ;
27342
27343   {
27344     try {
27345       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27346     } catch (std::out_of_range& e) {
27347       {
27348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27349       };
27350     } catch (std::exception& e) {
27351       {
27352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27353       };
27354     } catch (Dali::DaliException e) {
27355       {
27356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27357       };
27358     } catch (...) {
27359       {
27360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27361       };
27362     }
27363   }
27364
27365   jresult = (void *)result;
27366   return jresult;
27367 }
27368
27369
27370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27371   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27372
27373   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27374   {
27375     try {
27376       delete arg1;
27377     } catch (std::out_of_range& e) {
27378       {
27379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27380       };
27381     } catch (std::exception& e) {
27382       {
27383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27384       };
27385     } catch (Dali::DaliException e) {
27386       {
27387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27388       };
27389     } catch (...) {
27390       {
27391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27392       };
27393     }
27394   }
27395
27396 }
27397
27398
27399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27400   void * jresult ;
27401   unsigned int arg1 ;
27402   unsigned int arg2 ;
27403   unsigned int arg3 ;
27404   Dali::FrameBuffer result;
27405
27406   arg1 = (unsigned int)jarg1;
27407   arg2 = (unsigned int)jarg2;
27408   arg3 = (unsigned int)jarg3;
27409   {
27410     try {
27411       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27412     } catch (std::out_of_range& e) {
27413       {
27414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27415       };
27416     } catch (std::exception& e) {
27417       {
27418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27419       };
27420     } catch (Dali::DaliException e) {
27421       {
27422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27423       };
27424     } catch (...) {
27425       {
27426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27427       };
27428     }
27429   }
27430
27431   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27432   return jresult;
27433 }
27434
27435
27436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27437   void * jresult ;
27438   Dali::FrameBuffer *result = 0 ;
27439
27440   {
27441     try {
27442       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27443     } catch (std::out_of_range& e) {
27444       {
27445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27446       };
27447     } catch (std::exception& e) {
27448       {
27449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27450       };
27451     } catch (Dali::DaliException e) {
27452       {
27453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27454       };
27455     } catch (...) {
27456       {
27457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27458       };
27459     }
27460   }
27461
27462   jresult = (void *)result;
27463   return jresult;
27464 }
27465
27466
27467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27468   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27469
27470   arg1 = (Dali::FrameBuffer *)jarg1;
27471   {
27472     try {
27473       delete arg1;
27474     } catch (std::out_of_range& e) {
27475       {
27476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27477       };
27478     } catch (std::exception& e) {
27479       {
27480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27481       };
27482     } catch (Dali::DaliException e) {
27483       {
27484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27485       };
27486     } catch (...) {
27487       {
27488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27489       };
27490     }
27491   }
27492
27493 }
27494
27495
27496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27497   void * jresult ;
27498   Dali::FrameBuffer *arg1 = 0 ;
27499   Dali::FrameBuffer *result = 0 ;
27500
27501   arg1 = (Dali::FrameBuffer *)jarg1;
27502   if (!arg1) {
27503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27504     return 0;
27505   }
27506   {
27507     try {
27508       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27509     } catch (std::out_of_range& e) {
27510       {
27511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27512       };
27513     } catch (std::exception& e) {
27514       {
27515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27516       };
27517     } catch (Dali::DaliException e) {
27518       {
27519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27520       };
27521     } catch (...) {
27522       {
27523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27524       };
27525     }
27526   }
27527
27528   jresult = (void *)result;
27529   return jresult;
27530 }
27531
27532
27533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27534   void * jresult ;
27535   Dali::BaseHandle arg1 ;
27536   Dali::BaseHandle *argp1 ;
27537   Dali::FrameBuffer result;
27538
27539   argp1 = (Dali::BaseHandle *)jarg1;
27540   if (!argp1) {
27541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27542     return 0;
27543   }
27544   arg1 = *argp1;
27545   {
27546     try {
27547       result = Dali::FrameBuffer::DownCast(arg1);
27548     } catch (std::out_of_range& e) {
27549       {
27550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27551       };
27552     } catch (std::exception& e) {
27553       {
27554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27555       };
27556     } catch (Dali::DaliException e) {
27557       {
27558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27559       };
27560     } catch (...) {
27561       {
27562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27563       };
27564     }
27565   }
27566
27567   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27568   return jresult;
27569 }
27570
27571
27572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27573   void * jresult ;
27574   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27575   Dali::FrameBuffer *arg2 = 0 ;
27576   Dali::FrameBuffer *result = 0 ;
27577
27578   arg1 = (Dali::FrameBuffer *)jarg1;
27579   arg2 = (Dali::FrameBuffer *)jarg2;
27580   if (!arg2) {
27581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27582     return 0;
27583   }
27584   {
27585     try {
27586       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27587     } catch (std::out_of_range& e) {
27588       {
27589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27590       };
27591     } catch (std::exception& e) {
27592       {
27593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27594       };
27595     } catch (Dali::DaliException e) {
27596       {
27597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27598       };
27599     } catch (...) {
27600       {
27601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27602       };
27603     }
27604   }
27605
27606   jresult = (void *)result;
27607   return jresult;
27608 }
27609
27610
27611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27612   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27613   Dali::Texture *arg2 = 0 ;
27614
27615   arg1 = (Dali::FrameBuffer *)jarg1;
27616   arg2 = (Dali::Texture *)jarg2;
27617   if (!arg2) {
27618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27619     return ;
27620   }
27621   {
27622     try {
27623       (arg1)->AttachColorTexture(*arg2);
27624     } catch (std::out_of_range& e) {
27625       {
27626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27627       };
27628     } catch (std::exception& e) {
27629       {
27630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27631       };
27632     } catch (Dali::DaliException e) {
27633       {
27634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27635       };
27636     } catch (...) {
27637       {
27638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27639       };
27640     }
27641   }
27642
27643 }
27644
27645
27646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27647   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27648   Dali::Texture *arg2 = 0 ;
27649   unsigned int arg3 ;
27650   unsigned int arg4 ;
27651
27652   arg1 = (Dali::FrameBuffer *)jarg1;
27653   arg2 = (Dali::Texture *)jarg2;
27654   if (!arg2) {
27655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27656     return ;
27657   }
27658   arg3 = (unsigned int)jarg3;
27659   arg4 = (unsigned int)jarg4;
27660   {
27661     try {
27662       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27663     } catch (std::out_of_range& e) {
27664       {
27665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27666       };
27667     } catch (std::exception& e) {
27668       {
27669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27670       };
27671     } catch (Dali::DaliException e) {
27672       {
27673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27674       };
27675     } catch (...) {
27676       {
27677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27678       };
27679     }
27680   }
27681
27682 }
27683
27684
27685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27686   void * jresult ;
27687   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27688   Dali::Texture result;
27689
27690   arg1 = (Dali::FrameBuffer *)jarg1;
27691   {
27692     try {
27693       result = (arg1)->GetColorTexture();
27694     } catch (std::out_of_range& e) {
27695       {
27696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27697       };
27698     } catch (std::exception& e) {
27699       {
27700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27701       };
27702     } catch (Dali::DaliException e) {
27703       {
27704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27705       };
27706     } catch (...) {
27707       {
27708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27709       };
27710     }
27711   }
27712
27713   jresult = new Dali::Texture((const Dali::Texture &)result);
27714   return jresult;
27715 }
27716
27717
27718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27719   void * jresult ;
27720   Dali::RenderTaskList *result = 0 ;
27721
27722   {
27723     try {
27724       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27725     } catch (std::out_of_range& e) {
27726       {
27727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27728       };
27729     } catch (std::exception& e) {
27730       {
27731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27732       };
27733     } catch (Dali::DaliException e) {
27734       {
27735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27736       };
27737     } catch (...) {
27738       {
27739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27740       };
27741     }
27742   }
27743
27744   jresult = (void *)result;
27745   return jresult;
27746 }
27747
27748
27749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27750   void * jresult ;
27751   Dali::BaseHandle arg1 ;
27752   Dali::BaseHandle *argp1 ;
27753   Dali::RenderTaskList result;
27754
27755   argp1 = (Dali::BaseHandle *)jarg1;
27756   if (!argp1) {
27757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27758     return 0;
27759   }
27760   arg1 = *argp1;
27761   {
27762     try {
27763       result = Dali::RenderTaskList::DownCast(arg1);
27764     } catch (std::out_of_range& e) {
27765       {
27766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27767       };
27768     } catch (std::exception& e) {
27769       {
27770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27771       };
27772     } catch (Dali::DaliException e) {
27773       {
27774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27775       };
27776     } catch (...) {
27777       {
27778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27779       };
27780     }
27781   }
27782
27783   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27784   return jresult;
27785 }
27786
27787
27788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27789   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27790
27791   arg1 = (Dali::RenderTaskList *)jarg1;
27792   {
27793     try {
27794       delete arg1;
27795     } catch (std::out_of_range& e) {
27796       {
27797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27798       };
27799     } catch (std::exception& e) {
27800       {
27801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27802       };
27803     } catch (Dali::DaliException e) {
27804       {
27805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27806       };
27807     } catch (...) {
27808       {
27809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27810       };
27811     }
27812   }
27813
27814 }
27815
27816
27817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27818   void * jresult ;
27819   Dali::RenderTaskList *arg1 = 0 ;
27820   Dali::RenderTaskList *result = 0 ;
27821
27822   arg1 = (Dali::RenderTaskList *)jarg1;
27823   if (!arg1) {
27824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27825     return 0;
27826   }
27827   {
27828     try {
27829       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27830     } catch (std::out_of_range& e) {
27831       {
27832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27833       };
27834     } catch (std::exception& e) {
27835       {
27836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27837       };
27838     } catch (Dali::DaliException e) {
27839       {
27840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27841       };
27842     } catch (...) {
27843       {
27844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27845       };
27846     }
27847   }
27848
27849   jresult = (void *)result;
27850   return jresult;
27851 }
27852
27853
27854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27855   void * jresult ;
27856   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27857   Dali::RenderTaskList *arg2 = 0 ;
27858   Dali::RenderTaskList *result = 0 ;
27859
27860   arg1 = (Dali::RenderTaskList *)jarg1;
27861   arg2 = (Dali::RenderTaskList *)jarg2;
27862   if (!arg2) {
27863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27864     return 0;
27865   }
27866   {
27867     try {
27868       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27869     } catch (std::out_of_range& e) {
27870       {
27871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27872       };
27873     } catch (std::exception& e) {
27874       {
27875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27876       };
27877     } catch (Dali::DaliException e) {
27878       {
27879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27880       };
27881     } catch (...) {
27882       {
27883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27884       };
27885     }
27886   }
27887
27888   jresult = (void *)result;
27889   return jresult;
27890 }
27891
27892
27893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27894   void * jresult ;
27895   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27896   Dali::RenderTask result;
27897
27898   arg1 = (Dali::RenderTaskList *)jarg1;
27899   {
27900     try {
27901       result = (arg1)->CreateTask();
27902     } catch (std::out_of_range& e) {
27903       {
27904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27905       };
27906     } catch (std::exception& e) {
27907       {
27908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27909       };
27910     } catch (Dali::DaliException e) {
27911       {
27912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27913       };
27914     } catch (...) {
27915       {
27916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27917       };
27918     }
27919   }
27920
27921   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27922   return jresult;
27923 }
27924
27925
27926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27927   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27928   Dali::RenderTask arg2 ;
27929   Dali::RenderTask *argp2 ;
27930
27931   arg1 = (Dali::RenderTaskList *)jarg1;
27932   argp2 = (Dali::RenderTask *)jarg2;
27933   if (!argp2) {
27934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27935     return ;
27936   }
27937   arg2 = *argp2;
27938   {
27939     try {
27940       (arg1)->RemoveTask(arg2);
27941     } catch (std::out_of_range& e) {
27942       {
27943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27944       };
27945     } catch (std::exception& e) {
27946       {
27947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27948       };
27949     } catch (Dali::DaliException e) {
27950       {
27951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27952       };
27953     } catch (...) {
27954       {
27955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27956       };
27957     }
27958   }
27959
27960 }
27961
27962
27963 //// ===============================================end part 1 =================
27964
27965 //// ========================= part 2 ===============================
27966
27967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27968   unsigned int jresult ;
27969   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27970   unsigned int result;
27971
27972   arg1 = (Dali::RenderTaskList *)jarg1;
27973   {
27974     try {
27975       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27976     } catch (std::out_of_range& e) {
27977       {
27978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27979       };
27980     } catch (std::exception& e) {
27981       {
27982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27983       };
27984     } catch (Dali::DaliException e) {
27985       {
27986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27987       };
27988     } catch (...) {
27989       {
27990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27991       };
27992     }
27993   }
27994
27995   jresult = result;
27996   return jresult;
27997 }
27998
27999
28000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28001   void * jresult ;
28002   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28003   unsigned int arg2 ;
28004   Dali::RenderTask result;
28005
28006   arg1 = (Dali::RenderTaskList *)jarg1;
28007   arg2 = (unsigned int)jarg2;
28008   {
28009     try {
28010       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28011     } catch (std::out_of_range& e) {
28012       {
28013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28014       };
28015     } catch (std::exception& e) {
28016       {
28017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28018       };
28019     } catch (Dali::DaliException e) {
28020       {
28021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28022       };
28023     } catch (...) {
28024       {
28025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28026       };
28027     }
28028   }
28029
28030   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28031   return jresult;
28032 }
28033
28034
28035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28036   int jresult ;
28037   int result;
28038
28039   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28040   jresult = (int)result;
28041   return jresult;
28042 }
28043
28044
28045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28046   int jresult ;
28047   int result;
28048
28049   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28050   jresult = (int)result;
28051   return jresult;
28052 }
28053
28054
28055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28056   int jresult ;
28057   int result;
28058
28059   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28060   jresult = (int)result;
28061   return jresult;
28062 }
28063
28064
28065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28066   int jresult ;
28067   int result;
28068
28069   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28070   jresult = (int)result;
28071   return jresult;
28072 }
28073
28074
28075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28076   void * jresult ;
28077   Dali::RenderTask::Property *result = 0 ;
28078
28079   {
28080     try {
28081       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28082     } catch (std::out_of_range& e) {
28083       {
28084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28085       };
28086     } catch (std::exception& e) {
28087       {
28088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28089       };
28090     } catch (Dali::DaliException e) {
28091       {
28092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28093       };
28094     } catch (...) {
28095       {
28096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28097       };
28098     }
28099   }
28100
28101   jresult = (void *)result;
28102   return jresult;
28103 }
28104
28105
28106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28107   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28108
28109   arg1 = (Dali::RenderTask::Property *)jarg1;
28110   {
28111     try {
28112       delete arg1;
28113     } catch (std::out_of_range& e) {
28114       {
28115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28116       };
28117     } catch (std::exception& e) {
28118       {
28119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28120       };
28121     } catch (Dali::DaliException e) {
28122       {
28123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28124       };
28125     } catch (...) {
28126       {
28127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28128       };
28129     }
28130   }
28131
28132 }
28133
28134
28135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28136   void * jresult ;
28137   bool (*result)(Dali::Vector2 &) = 0 ;
28138
28139   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28140   jresult = (void *)result;
28141   return jresult;
28142 }
28143
28144
28145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28146   void * jresult ;
28147   bool (*result)(Dali::Vector2 &) = 0 ;
28148
28149   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28150   jresult = (void *)result;
28151   return jresult;
28152 }
28153
28154
28155 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28156   unsigned int jresult ;
28157   bool result;
28158
28159   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28160   jresult = result;
28161   return jresult;
28162 }
28163
28164
28165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28166   unsigned int jresult ;
28167   bool result;
28168
28169   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28170   jresult = result;
28171   return jresult;
28172 }
28173
28174
28175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28176   void * jresult ;
28177   Dali::Vector4 *result = 0 ;
28178
28179   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28180   jresult = (void *)result;
28181   return jresult;
28182 }
28183
28184
28185 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28186   unsigned int jresult ;
28187   bool result;
28188
28189   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28190   jresult = result;
28191   return jresult;
28192 }
28193
28194
28195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28196   unsigned int jresult ;
28197   bool result;
28198
28199   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28200   jresult = result;
28201   return jresult;
28202 }
28203
28204
28205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28206   unsigned int jresult ;
28207   unsigned int result;
28208
28209   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28210   jresult = result;
28211   return jresult;
28212 }
28213
28214
28215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28216   void * jresult ;
28217   Dali::RenderTask *result = 0 ;
28218
28219   {
28220     try {
28221       result = (Dali::RenderTask *)new Dali::RenderTask();
28222     } catch (std::out_of_range& e) {
28223       {
28224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28225       };
28226     } catch (std::exception& e) {
28227       {
28228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28229       };
28230     } catch (Dali::DaliException e) {
28231       {
28232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28233       };
28234     } catch (...) {
28235       {
28236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28237       };
28238     }
28239   }
28240
28241   jresult = (void *)result;
28242   return jresult;
28243 }
28244
28245
28246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28247   void * jresult ;
28248   Dali::BaseHandle arg1 ;
28249   Dali::BaseHandle *argp1 ;
28250   Dali::RenderTask result;
28251
28252   argp1 = (Dali::BaseHandle *)jarg1;
28253   if (!argp1) {
28254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28255     return 0;
28256   }
28257   arg1 = *argp1;
28258   {
28259     try {
28260       result = Dali::RenderTask::DownCast(arg1);
28261     } catch (std::out_of_range& e) {
28262       {
28263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28264       };
28265     } catch (std::exception& e) {
28266       {
28267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28268       };
28269     } catch (Dali::DaliException e) {
28270       {
28271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28272       };
28273     } catch (...) {
28274       {
28275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28276       };
28277     }
28278   }
28279
28280   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28281   return jresult;
28282 }
28283
28284
28285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28286   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28287
28288   arg1 = (Dali::RenderTask *)jarg1;
28289   {
28290     try {
28291       delete arg1;
28292     } catch (std::out_of_range& e) {
28293       {
28294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28295       };
28296     } catch (std::exception& e) {
28297       {
28298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28299       };
28300     } catch (Dali::DaliException e) {
28301       {
28302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28303       };
28304     } catch (...) {
28305       {
28306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28307       };
28308     }
28309   }
28310
28311 }
28312
28313
28314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28315   void * jresult ;
28316   Dali::RenderTask *arg1 = 0 ;
28317   Dali::RenderTask *result = 0 ;
28318
28319   arg1 = (Dali::RenderTask *)jarg1;
28320   if (!arg1) {
28321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28322     return 0;
28323   }
28324   {
28325     try {
28326       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28327     } catch (std::out_of_range& e) {
28328       {
28329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28330       };
28331     } catch (std::exception& e) {
28332       {
28333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28334       };
28335     } catch (Dali::DaliException e) {
28336       {
28337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28338       };
28339     } catch (...) {
28340       {
28341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28342       };
28343     }
28344   }
28345
28346   jresult = (void *)result;
28347   return jresult;
28348 }
28349
28350
28351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28352   void * jresult ;
28353   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28354   Dali::RenderTask *arg2 = 0 ;
28355   Dali::RenderTask *result = 0 ;
28356
28357   arg1 = (Dali::RenderTask *)jarg1;
28358   arg2 = (Dali::RenderTask *)jarg2;
28359   if (!arg2) {
28360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28361     return 0;
28362   }
28363   {
28364     try {
28365       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28366     } catch (std::out_of_range& e) {
28367       {
28368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28369       };
28370     } catch (std::exception& e) {
28371       {
28372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28373       };
28374     } catch (Dali::DaliException e) {
28375       {
28376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28377       };
28378     } catch (...) {
28379       {
28380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28381       };
28382     }
28383   }
28384
28385   jresult = (void *)result;
28386   return jresult;
28387 }
28388
28389
28390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28391   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28392   Dali::Actor arg2 ;
28393   Dali::Actor *argp2 ;
28394
28395   arg1 = (Dali::RenderTask *)jarg1;
28396   argp2 = (Dali::Actor *)jarg2;
28397   if (!argp2) {
28398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28399     return ;
28400   }
28401   arg2 = *argp2;
28402   {
28403     try {
28404       (arg1)->SetSourceActor(arg2);
28405     } catch (std::out_of_range& e) {
28406       {
28407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28408       };
28409     } catch (std::exception& e) {
28410       {
28411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28412       };
28413     } catch (Dali::DaliException e) {
28414       {
28415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28416       };
28417     } catch (...) {
28418       {
28419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28420       };
28421     }
28422   }
28423
28424 }
28425
28426
28427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28428   void * jresult ;
28429   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28430   Dali::Actor result;
28431
28432   arg1 = (Dali::RenderTask *)jarg1;
28433   {
28434     try {
28435       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28436     } catch (std::out_of_range& e) {
28437       {
28438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28439       };
28440     } catch (std::exception& e) {
28441       {
28442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28443       };
28444     } catch (Dali::DaliException e) {
28445       {
28446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28447       };
28448     } catch (...) {
28449       {
28450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28451       };
28452     }
28453   }
28454
28455   jresult = new Dali::Actor((const Dali::Actor &)result);
28456   return jresult;
28457 }
28458
28459
28460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28461   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28462   bool arg2 ;
28463
28464   arg1 = (Dali::RenderTask *)jarg1;
28465   arg2 = jarg2 ? true : false;
28466   {
28467     try {
28468       (arg1)->SetExclusive(arg2);
28469     } catch (std::out_of_range& e) {
28470       {
28471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28472       };
28473     } catch (std::exception& e) {
28474       {
28475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28476       };
28477     } catch (Dali::DaliException e) {
28478       {
28479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28480       };
28481     } catch (...) {
28482       {
28483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28484       };
28485     }
28486   }
28487
28488 }
28489
28490
28491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28492   unsigned int jresult ;
28493   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28494   bool result;
28495
28496   arg1 = (Dali::RenderTask *)jarg1;
28497   {
28498     try {
28499       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28500     } catch (std::out_of_range& e) {
28501       {
28502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28503       };
28504     } catch (std::exception& e) {
28505       {
28506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28507       };
28508     } catch (Dali::DaliException e) {
28509       {
28510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28511       };
28512     } catch (...) {
28513       {
28514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28515       };
28516     }
28517   }
28518
28519   jresult = result;
28520   return jresult;
28521 }
28522
28523
28524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28525   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28526   bool arg2 ;
28527
28528   arg1 = (Dali::RenderTask *)jarg1;
28529   arg2 = jarg2 ? true : false;
28530   {
28531     try {
28532       (arg1)->SetInputEnabled(arg2);
28533     } catch (std::out_of_range& e) {
28534       {
28535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28536       };
28537     } catch (std::exception& e) {
28538       {
28539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28540       };
28541     } catch (Dali::DaliException e) {
28542       {
28543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28544       };
28545     } catch (...) {
28546       {
28547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28548       };
28549     }
28550   }
28551
28552 }
28553
28554
28555 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28556   unsigned int jresult ;
28557   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28558   bool result;
28559
28560   arg1 = (Dali::RenderTask *)jarg1;
28561   {
28562     try {
28563       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28564     } catch (std::out_of_range& e) {
28565       {
28566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28567       };
28568     } catch (std::exception& e) {
28569       {
28570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28571       };
28572     } catch (Dali::DaliException e) {
28573       {
28574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28575       };
28576     } catch (...) {
28577       {
28578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28579       };
28580     }
28581   }
28582
28583   jresult = result;
28584   return jresult;
28585 }
28586
28587
28588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28589   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28590   Dali::CameraActor arg2 ;
28591   Dali::CameraActor *argp2 ;
28592
28593   arg1 = (Dali::RenderTask *)jarg1;
28594   argp2 = (Dali::CameraActor *)jarg2;
28595   if (!argp2) {
28596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28597     return ;
28598   }
28599   arg2 = *argp2;
28600   {
28601     try {
28602       (arg1)->SetCameraActor(arg2);
28603     } catch (std::out_of_range& e) {
28604       {
28605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28606       };
28607     } catch (std::exception& e) {
28608       {
28609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28610       };
28611     } catch (Dali::DaliException e) {
28612       {
28613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28614       };
28615     } catch (...) {
28616       {
28617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28618       };
28619     }
28620   }
28621
28622 }
28623
28624
28625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28626   void * jresult ;
28627   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28628   Dali::CameraActor result;
28629
28630   arg1 = (Dali::RenderTask *)jarg1;
28631   {
28632     try {
28633       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28634     } catch (std::out_of_range& e) {
28635       {
28636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28637       };
28638     } catch (std::exception& e) {
28639       {
28640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28641       };
28642     } catch (Dali::DaliException e) {
28643       {
28644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28645       };
28646     } catch (...) {
28647       {
28648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28649       };
28650     }
28651   }
28652
28653   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28654   return jresult;
28655 }
28656
28657
28658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28659   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28660   Dali::FrameBufferImage arg2 ;
28661   Dali::FrameBufferImage *argp2 ;
28662
28663   arg1 = (Dali::RenderTask *)jarg1;
28664   argp2 = (Dali::FrameBufferImage *)jarg2;
28665   if (!argp2) {
28666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28667     return ;
28668   }
28669   arg2 = *argp2;
28670   {
28671     try {
28672       (arg1)->SetTargetFrameBuffer(arg2);
28673     } catch (std::out_of_range& e) {
28674       {
28675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28676       };
28677     } catch (std::exception& e) {
28678       {
28679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28680       };
28681     } catch (Dali::DaliException e) {
28682       {
28683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28684       };
28685     } catch (...) {
28686       {
28687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28688       };
28689     }
28690   }
28691
28692 }
28693
28694
28695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28696   void * jresult ;
28697   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28698   Dali::FrameBufferImage result;
28699
28700   arg1 = (Dali::RenderTask *)jarg1;
28701   {
28702     try {
28703       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28704     } catch (std::out_of_range& e) {
28705       {
28706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28707       };
28708     } catch (std::exception& e) {
28709       {
28710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28711       };
28712     } catch (Dali::DaliException e) {
28713       {
28714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28715       };
28716     } catch (...) {
28717       {
28718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28719       };
28720     }
28721   }
28722
28723   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28724   return jresult;
28725 }
28726
28727
28728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28729   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28730   Dali::FrameBuffer arg2 ;
28731   Dali::FrameBuffer *argp2 ;
28732
28733   arg1 = (Dali::RenderTask *)jarg1;
28734   argp2 = (Dali::FrameBuffer *)jarg2;
28735   if (!argp2) {
28736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28737     return ;
28738   }
28739   arg2 = *argp2;
28740   {
28741     try {
28742       (arg1)->SetFrameBuffer(arg2);
28743     } catch (std::out_of_range& e) {
28744       {
28745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28746       };
28747     } catch (std::exception& e) {
28748       {
28749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28750       };
28751     } catch (Dali::DaliException e) {
28752       {
28753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28754       };
28755     } catch (...) {
28756       {
28757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28758       };
28759     }
28760   }
28761
28762 }
28763
28764
28765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28766   void * jresult ;
28767   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28768   Dali::FrameBuffer result;
28769
28770   arg1 = (Dali::RenderTask *)jarg1;
28771   {
28772     try {
28773       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28774     } catch (std::out_of_range& e) {
28775       {
28776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28777       };
28778     } catch (std::exception& e) {
28779       {
28780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28781       };
28782     } catch (Dali::DaliException e) {
28783       {
28784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28785       };
28786     } catch (...) {
28787       {
28788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28789       };
28790     }
28791   }
28792
28793   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28794   return jresult;
28795 }
28796
28797
28798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28799   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28800   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28801
28802   arg1 = (Dali::RenderTask *)jarg1;
28803   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28804   {
28805     try {
28806       (arg1)->SetScreenToFrameBufferFunction(arg2);
28807     } catch (std::out_of_range& e) {
28808       {
28809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28810       };
28811     } catch (std::exception& e) {
28812       {
28813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28814       };
28815     } catch (Dali::DaliException e) {
28816       {
28817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28818       };
28819     } catch (...) {
28820       {
28821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28822       };
28823     }
28824   }
28825
28826 }
28827
28828
28829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28830   void * jresult ;
28831   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28832   Dali::RenderTask::ScreenToFrameBufferFunction result;
28833
28834   arg1 = (Dali::RenderTask *)jarg1;
28835   {
28836     try {
28837       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28838     } catch (std::out_of_range& e) {
28839       {
28840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28841       };
28842     } catch (std::exception& e) {
28843       {
28844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28845       };
28846     } catch (Dali::DaliException e) {
28847       {
28848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28849       };
28850     } catch (...) {
28851       {
28852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28853       };
28854     }
28855   }
28856
28857   jresult = (void *)result;
28858   return jresult;
28859 }
28860
28861
28862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28863   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28864   Dali::Actor arg2 ;
28865   Dali::Actor *argp2 ;
28866
28867   arg1 = (Dali::RenderTask *)jarg1;
28868   argp2 = (Dali::Actor *)jarg2;
28869   if (!argp2) {
28870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28871     return ;
28872   }
28873   arg2 = *argp2;
28874   {
28875     try {
28876       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28877     } catch (std::out_of_range& e) {
28878       {
28879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28880       };
28881     } catch (std::exception& e) {
28882       {
28883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28884       };
28885     } catch (Dali::DaliException e) {
28886       {
28887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28888       };
28889     } catch (...) {
28890       {
28891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28892       };
28893     }
28894   }
28895
28896 }
28897
28898
28899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28900   void * jresult ;
28901   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28902   Dali::Actor result;
28903
28904   arg1 = (Dali::RenderTask *)jarg1;
28905   {
28906     try {
28907       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28908     } catch (std::out_of_range& e) {
28909       {
28910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28911       };
28912     } catch (std::exception& e) {
28913       {
28914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28915       };
28916     } catch (Dali::DaliException e) {
28917       {
28918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28919       };
28920     } catch (...) {
28921       {
28922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28923       };
28924     }
28925   }
28926
28927   jresult = new Dali::Actor((const Dali::Actor &)result);
28928   return jresult;
28929 }
28930
28931
28932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28933   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28934   Dali::Vector2 arg2 ;
28935   Dali::Vector2 *argp2 ;
28936
28937   arg1 = (Dali::RenderTask *)jarg1;
28938   argp2 = (Dali::Vector2 *)jarg2;
28939   if (!argp2) {
28940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28941     return ;
28942   }
28943   arg2 = *argp2;
28944   {
28945     try {
28946       (arg1)->SetViewportPosition(arg2);
28947     } catch (std::out_of_range& e) {
28948       {
28949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28950       };
28951     } catch (std::exception& e) {
28952       {
28953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28954       };
28955     } catch (Dali::DaliException e) {
28956       {
28957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28958       };
28959     } catch (...) {
28960       {
28961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28962       };
28963     }
28964   }
28965
28966 }
28967
28968
28969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28970   void * jresult ;
28971   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28972   Dali::Vector2 result;
28973
28974   arg1 = (Dali::RenderTask *)jarg1;
28975   {
28976     try {
28977       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28978     } catch (std::out_of_range& e) {
28979       {
28980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28981       };
28982     } catch (std::exception& e) {
28983       {
28984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28985       };
28986     } catch (Dali::DaliException e) {
28987       {
28988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28989       };
28990     } catch (...) {
28991       {
28992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28993       };
28994     }
28995   }
28996
28997   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28998   return jresult;
28999 }
29000
29001
29002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29003   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29004   Dali::Vector2 arg2 ;
29005   Dali::Vector2 *argp2 ;
29006
29007   arg1 = (Dali::RenderTask *)jarg1;
29008   argp2 = (Dali::Vector2 *)jarg2;
29009   if (!argp2) {
29010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29011     return ;
29012   }
29013   arg2 = *argp2;
29014   {
29015     try {
29016       (arg1)->SetViewportSize(arg2);
29017     } catch (std::out_of_range& e) {
29018       {
29019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29020       };
29021     } catch (std::exception& e) {
29022       {
29023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29024       };
29025     } catch (Dali::DaliException e) {
29026       {
29027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29028       };
29029     } catch (...) {
29030       {
29031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29032       };
29033     }
29034   }
29035
29036 }
29037
29038
29039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29040   void * jresult ;
29041   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29042   Dali::Vector2 result;
29043
29044   arg1 = (Dali::RenderTask *)jarg1;
29045   {
29046     try {
29047       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29048     } catch (std::out_of_range& e) {
29049       {
29050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29051       };
29052     } catch (std::exception& e) {
29053       {
29054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29055       };
29056     } catch (Dali::DaliException e) {
29057       {
29058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29059       };
29060     } catch (...) {
29061       {
29062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29063       };
29064     }
29065   }
29066
29067   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29068   return jresult;
29069 }
29070
29071
29072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29073   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29074   Dali::Viewport arg2 ;
29075   Dali::Viewport *argp2 ;
29076
29077   arg1 = (Dali::RenderTask *)jarg1;
29078   argp2 = (Dali::Viewport *)jarg2;
29079   if (!argp2) {
29080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29081     return ;
29082   }
29083   arg2 = *argp2;
29084   {
29085     try {
29086       (arg1)->SetViewport(arg2);
29087     } catch (std::out_of_range& e) {
29088       {
29089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29090       };
29091     } catch (std::exception& e) {
29092       {
29093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29094       };
29095     } catch (Dali::DaliException e) {
29096       {
29097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29098       };
29099     } catch (...) {
29100       {
29101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29102       };
29103     }
29104   }
29105
29106 }
29107
29108
29109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29110   void * jresult ;
29111   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29112   Dali::Viewport result;
29113
29114   arg1 = (Dali::RenderTask *)jarg1;
29115   {
29116     try {
29117       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29118     } catch (std::out_of_range& e) {
29119       {
29120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29121       };
29122     } catch (std::exception& e) {
29123       {
29124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29125       };
29126     } catch (Dali::DaliException e) {
29127       {
29128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29129       };
29130     } catch (...) {
29131       {
29132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29133       };
29134     }
29135   }
29136
29137   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29138   return jresult;
29139 }
29140
29141
29142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29143   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29144   Dali::Vector4 *arg2 = 0 ;
29145
29146   arg1 = (Dali::RenderTask *)jarg1;
29147   arg2 = (Dali::Vector4 *)jarg2;
29148   if (!arg2) {
29149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29150     return ;
29151   }
29152   {
29153     try {
29154       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29155     } catch (std::out_of_range& e) {
29156       {
29157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29158       };
29159     } catch (std::exception& e) {
29160       {
29161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29162       };
29163     } catch (Dali::DaliException e) {
29164       {
29165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29166       };
29167     } catch (...) {
29168       {
29169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29170       };
29171     }
29172   }
29173
29174 }
29175
29176
29177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29178   void * jresult ;
29179   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29180   Dali::Vector4 result;
29181
29182   arg1 = (Dali::RenderTask *)jarg1;
29183   {
29184     try {
29185       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29186     } catch (std::out_of_range& e) {
29187       {
29188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29189       };
29190     } catch (std::exception& e) {
29191       {
29192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29193       };
29194     } catch (Dali::DaliException e) {
29195       {
29196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29197       };
29198     } catch (...) {
29199       {
29200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29201       };
29202     }
29203   }
29204
29205   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29206   return jresult;
29207 }
29208
29209
29210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29211   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29212   bool arg2 ;
29213
29214   arg1 = (Dali::RenderTask *)jarg1;
29215   arg2 = jarg2 ? true : false;
29216   {
29217     try {
29218       (arg1)->SetClearEnabled(arg2);
29219     } catch (std::out_of_range& e) {
29220       {
29221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29222       };
29223     } catch (std::exception& e) {
29224       {
29225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29226       };
29227     } catch (Dali::DaliException e) {
29228       {
29229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29230       };
29231     } catch (...) {
29232       {
29233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29234       };
29235     }
29236   }
29237
29238 }
29239
29240
29241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29242   unsigned int jresult ;
29243   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29244   bool result;
29245
29246   arg1 = (Dali::RenderTask *)jarg1;
29247   {
29248     try {
29249       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
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_SetCullMode(void * jarg1, unsigned int jarg2) {
29275   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29276   bool arg2 ;
29277
29278   arg1 = (Dali::RenderTask *)jarg1;
29279   arg2 = jarg2 ? true : false;
29280   {
29281     try {
29282       (arg1)->SetCullMode(arg2);
29283     } catch (std::out_of_range& e) {
29284       {
29285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29286       };
29287     } catch (std::exception& e) {
29288       {
29289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29290       };
29291     } catch (Dali::DaliException e) {
29292       {
29293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29294       };
29295     } catch (...) {
29296       {
29297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29298       };
29299     }
29300   }
29301
29302 }
29303
29304
29305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29306   unsigned int jresult ;
29307   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29308   bool result;
29309
29310   arg1 = (Dali::RenderTask *)jarg1;
29311   {
29312     try {
29313       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29314     } catch (std::out_of_range& e) {
29315       {
29316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29317       };
29318     } catch (std::exception& e) {
29319       {
29320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29321       };
29322     } catch (Dali::DaliException e) {
29323       {
29324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29325       };
29326     } catch (...) {
29327       {
29328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29329       };
29330     }
29331   }
29332
29333   jresult = result;
29334   return jresult;
29335 }
29336
29337
29338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29339   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29340   unsigned int arg2 ;
29341
29342   arg1 = (Dali::RenderTask *)jarg1;
29343   arg2 = (unsigned int)jarg2;
29344   {
29345     try {
29346       (arg1)->SetRefreshRate(arg2);
29347     } catch (std::out_of_range& e) {
29348       {
29349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29350       };
29351     } catch (std::exception& e) {
29352       {
29353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29354       };
29355     } catch (Dali::DaliException e) {
29356       {
29357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29358       };
29359     } catch (...) {
29360       {
29361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29362       };
29363     }
29364   }
29365
29366 }
29367
29368
29369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29370   unsigned int jresult ;
29371   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29372   unsigned int result;
29373
29374   arg1 = (Dali::RenderTask *)jarg1;
29375   {
29376     try {
29377       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29378     } catch (std::out_of_range& e) {
29379       {
29380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29381       };
29382     } catch (std::exception& e) {
29383       {
29384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29385       };
29386     } catch (Dali::DaliException e) {
29387       {
29388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29389       };
29390     } catch (...) {
29391       {
29392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29393       };
29394     }
29395   }
29396
29397   jresult = result;
29398   return jresult;
29399 }
29400
29401
29402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29403   unsigned int jresult ;
29404   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29405   Dali::Vector3 *arg2 = 0 ;
29406   float *arg3 = 0 ;
29407   float *arg4 = 0 ;
29408   bool result;
29409
29410   arg1 = (Dali::RenderTask *)jarg1;
29411   arg2 = (Dali::Vector3 *)jarg2;
29412   if (!arg2) {
29413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29414     return 0;
29415   }
29416   arg3 = (float *)jarg3;
29417   arg4 = (float *)jarg4;
29418   {
29419     try {
29420       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29421     } catch (std::out_of_range& e) {
29422       {
29423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29424       };
29425     } catch (std::exception& e) {
29426       {
29427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29428       };
29429     } catch (Dali::DaliException e) {
29430       {
29431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29432       };
29433     } catch (...) {
29434       {
29435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29436       };
29437     }
29438   }
29439
29440   jresult = result;
29441   return jresult;
29442 }
29443
29444
29445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29446   unsigned int jresult ;
29447   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29448   Dali::Actor arg2 ;
29449   float arg3 ;
29450   float arg4 ;
29451   float *arg5 = 0 ;
29452   float *arg6 = 0 ;
29453   Dali::Actor *argp2 ;
29454   bool result;
29455
29456   arg1 = (Dali::RenderTask *)jarg1;
29457   argp2 = (Dali::Actor *)jarg2;
29458   if (!argp2) {
29459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29460     return 0;
29461   }
29462   arg2 = *argp2;
29463   arg3 = (float)jarg3;
29464   arg4 = (float)jarg4;
29465   arg5 = (float *)jarg5;
29466   arg6 = (float *)jarg6;
29467   {
29468     try {
29469       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29470     } catch (std::out_of_range& e) {
29471       {
29472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29473       };
29474     } catch (std::exception& e) {
29475       {
29476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29477       };
29478     } catch (Dali::DaliException e) {
29479       {
29480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29481       };
29482     } catch (...) {
29483       {
29484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29485       };
29486     }
29487   }
29488
29489   jresult = result;
29490   return jresult;
29491 }
29492
29493
29494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29495   void * jresult ;
29496   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29497   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29498
29499   arg1 = (Dali::RenderTask *)jarg1;
29500   {
29501     try {
29502       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29503     } catch (std::out_of_range& e) {
29504       {
29505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29506       };
29507     } catch (std::exception& e) {
29508       {
29509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29510       };
29511     } catch (Dali::DaliException e) {
29512       {
29513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29514       };
29515     } catch (...) {
29516       {
29517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29518       };
29519     }
29520   }
29521
29522   jresult = (void *)result;
29523   return jresult;
29524 }
29525
29526
29527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29528   void * jresult ;
29529   int arg1 ;
29530   Dali::TouchPoint::State arg2 ;
29531   float arg3 ;
29532   float arg4 ;
29533   Dali::TouchPoint *result = 0 ;
29534
29535   arg1 = (int)jarg1;
29536   arg2 = (Dali::TouchPoint::State)jarg2;
29537   arg3 = (float)jarg3;
29538   arg4 = (float)jarg4;
29539   {
29540     try {
29541       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29542     } catch (std::out_of_range& e) {
29543       {
29544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29545       };
29546     } catch (std::exception& e) {
29547       {
29548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29549       };
29550     } catch (Dali::DaliException e) {
29551       {
29552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29553       };
29554     } catch (...) {
29555       {
29556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29557       };
29558     }
29559   }
29560
29561   jresult = (void *)result;
29562   return jresult;
29563 }
29564
29565
29566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29567   void * jresult ;
29568   int arg1 ;
29569   Dali::TouchPoint::State arg2 ;
29570   float arg3 ;
29571   float arg4 ;
29572   float arg5 ;
29573   float arg6 ;
29574   Dali::TouchPoint *result = 0 ;
29575
29576   arg1 = (int)jarg1;
29577   arg2 = (Dali::TouchPoint::State)jarg2;
29578   arg3 = (float)jarg3;
29579   arg4 = (float)jarg4;
29580   arg5 = (float)jarg5;
29581   arg6 = (float)jarg6;
29582   {
29583     try {
29584       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29585     } catch (std::out_of_range& e) {
29586       {
29587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29588       };
29589     } catch (std::exception& e) {
29590       {
29591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29592       };
29593     } catch (Dali::DaliException e) {
29594       {
29595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29596       };
29597     } catch (...) {
29598       {
29599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29600       };
29601     }
29602   }
29603
29604   jresult = (void *)result;
29605   return jresult;
29606 }
29607
29608
29609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29610   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29611
29612   arg1 = (Dali::TouchPoint *)jarg1;
29613   {
29614     try {
29615       delete arg1;
29616     } catch (std::out_of_range& e) {
29617       {
29618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29619       };
29620     } catch (std::exception& e) {
29621       {
29622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29623       };
29624     } catch (Dali::DaliException e) {
29625       {
29626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29627       };
29628     } catch (...) {
29629       {
29630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29631       };
29632     }
29633   }
29634
29635 }
29636
29637
29638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29639   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29640   int arg2 ;
29641
29642   arg1 = (Dali::TouchPoint *)jarg1;
29643   arg2 = (int)jarg2;
29644   if (arg1) (arg1)->deviceId = arg2;
29645 }
29646
29647
29648 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29649   int jresult ;
29650   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29651   int result;
29652
29653   arg1 = (Dali::TouchPoint *)jarg1;
29654   result = (int) ((arg1)->deviceId);
29655   jresult = result;
29656   return jresult;
29657 }
29658
29659
29660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29661   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29662   Dali::TouchPoint::State arg2 ;
29663
29664   arg1 = (Dali::TouchPoint *)jarg1;
29665   arg2 = (Dali::TouchPoint::State)jarg2;
29666   if (arg1) (arg1)->state = arg2;
29667 }
29668
29669
29670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29671   int jresult ;
29672   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29673   Dali::TouchPoint::State result;
29674
29675   arg1 = (Dali::TouchPoint *)jarg1;
29676   result = (Dali::TouchPoint::State) ((arg1)->state);
29677   jresult = (int)result;
29678   return jresult;
29679 }
29680
29681
29682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29683   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29684   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29685
29686   arg1 = (Dali::TouchPoint *)jarg1;
29687   arg2 = (Dali::Actor *)jarg2;
29688   if (arg1) (arg1)->hitActor = *arg2;
29689 }
29690
29691
29692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29693   void * jresult ;
29694   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29695   Dali::Actor *result = 0 ;
29696
29697   arg1 = (Dali::TouchPoint *)jarg1;
29698   result = (Dali::Actor *)& ((arg1)->hitActor);
29699   jresult = (void *)result;
29700   return jresult;
29701 }
29702
29703
29704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29705   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29706   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29707
29708   arg1 = (Dali::TouchPoint *)jarg1;
29709   arg2 = (Dali::Vector2 *)jarg2;
29710   if (arg1) (arg1)->local = *arg2;
29711 }
29712
29713
29714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29715   void * jresult ;
29716   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29717   Dali::Vector2 *result = 0 ;
29718
29719   arg1 = (Dali::TouchPoint *)jarg1;
29720   result = (Dali::Vector2 *)& ((arg1)->local);
29721   jresult = (void *)result;
29722   return jresult;
29723 }
29724
29725
29726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29727   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29728   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29729
29730   arg1 = (Dali::TouchPoint *)jarg1;
29731   arg2 = (Dali::Vector2 *)jarg2;
29732   if (arg1) (arg1)->screen = *arg2;
29733 }
29734
29735
29736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29737   void * jresult ;
29738   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29739   Dali::Vector2 *result = 0 ;
29740
29741   arg1 = (Dali::TouchPoint *)jarg1;
29742   result = (Dali::Vector2 *)& ((arg1)->screen);
29743   jresult = (void *)result;
29744   return jresult;
29745 }
29746
29747
29748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29749   void * jresult ;
29750   Dali::TouchData *result = 0 ;
29751
29752   {
29753     try {
29754       result = (Dali::TouchData *)new Dali::TouchData();
29755     } catch (std::out_of_range& e) {
29756       {
29757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29758       };
29759     } catch (std::exception& e) {
29760       {
29761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29762       };
29763     } catch (Dali::DaliException e) {
29764       {
29765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29766       };
29767     } catch (...) {
29768       {
29769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29770       };
29771     }
29772   }
29773
29774   jresult = (void *)result;
29775   return jresult;
29776 }
29777
29778
29779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29780   void * jresult ;
29781   Dali::TouchData *arg1 = 0 ;
29782   Dali::TouchData *result = 0 ;
29783
29784   arg1 = (Dali::TouchData *)jarg1;
29785   if (!arg1) {
29786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29787     return 0;
29788   }
29789   {
29790     try {
29791       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29792     } catch (std::out_of_range& e) {
29793       {
29794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29795       };
29796     } catch (std::exception& e) {
29797       {
29798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29799       };
29800     } catch (Dali::DaliException e) {
29801       {
29802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29803       };
29804     } catch (...) {
29805       {
29806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29807       };
29808     }
29809   }
29810
29811   jresult = (void *)result;
29812   return jresult;
29813 }
29814
29815
29816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29817   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29818
29819   arg1 = (Dali::TouchData *)jarg1;
29820   {
29821     try {
29822       delete arg1;
29823     } catch (std::out_of_range& e) {
29824       {
29825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29826       };
29827     } catch (std::exception& e) {
29828       {
29829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29830       };
29831     } catch (Dali::DaliException e) {
29832       {
29833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29834       };
29835     } catch (...) {
29836       {
29837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29838       };
29839     }
29840   }
29841
29842 }
29843
29844
29845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29846   void * jresult ;
29847   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29848   Dali::TouchData *arg2 = 0 ;
29849   Dali::TouchData *result = 0 ;
29850
29851   arg1 = (Dali::TouchData *)jarg1;
29852   arg2 = (Dali::TouchData *)jarg2;
29853   if (!arg2) {
29854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29855     return 0;
29856   }
29857   {
29858     try {
29859       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29860     } catch (std::out_of_range& e) {
29861       {
29862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29863       };
29864     } catch (std::exception& e) {
29865       {
29866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29867       };
29868     } catch (Dali::DaliException e) {
29869       {
29870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29871       };
29872     } catch (...) {
29873       {
29874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29875       };
29876     }
29877   }
29878
29879   jresult = (void *)result;
29880   return jresult;
29881 }
29882
29883
29884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29885   unsigned long jresult ;
29886   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29887   unsigned long result;
29888
29889   arg1 = (Dali::TouchData *)jarg1;
29890   {
29891     try {
29892       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29893     } catch (std::out_of_range& e) {
29894       {
29895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29896       };
29897     } catch (std::exception& e) {
29898       {
29899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29900       };
29901     } catch (Dali::DaliException e) {
29902       {
29903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29904       };
29905     } catch (...) {
29906       {
29907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29908       };
29909     }
29910   }
29911
29912   jresult = (unsigned long)result;
29913   return jresult;
29914 }
29915
29916
29917 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29918   unsigned long jresult ;
29919   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29920   std::size_t result;
29921
29922   arg1 = (Dali::TouchData *)jarg1;
29923   {
29924     try {
29925       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29926     } catch (std::out_of_range& e) {
29927       {
29928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29929       };
29930     } catch (std::exception& e) {
29931       {
29932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29933       };
29934     } catch (Dali::DaliException e) {
29935       {
29936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29937       };
29938     } catch (...) {
29939       {
29940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29941       };
29942     }
29943   }
29944
29945   jresult = (unsigned long)result;
29946   return jresult;
29947 }
29948
29949
29950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29951   int jresult ;
29952   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29953   std::size_t arg2 ;
29954   int32_t result;
29955
29956   arg1 = (Dali::TouchData *)jarg1;
29957   arg2 = (std::size_t)jarg2;
29958   {
29959     try {
29960       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29961     } catch (std::out_of_range& e) {
29962       {
29963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29964       };
29965     } catch (std::exception& e) {
29966       {
29967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29968       };
29969     } catch (Dali::DaliException e) {
29970       {
29971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29972       };
29973     } catch (...) {
29974       {
29975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29976       };
29977     }
29978   }
29979
29980   jresult = result;
29981   return jresult;
29982 }
29983
29984
29985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29986   int jresult ;
29987   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29988   std::size_t arg2 ;
29989   Dali::PointState::Type result;
29990
29991   arg1 = (Dali::TouchData *)jarg1;
29992   arg2 = (std::size_t)jarg2;
29993   {
29994     try {
29995       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29996     } catch (std::out_of_range& e) {
29997       {
29998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29999       };
30000     } catch (std::exception& e) {
30001       {
30002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30003       };
30004     } catch (Dali::DaliException e) {
30005       {
30006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30007       };
30008     } catch (...) {
30009       {
30010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30011       };
30012     }
30013   }
30014
30015   jresult = (int)result;
30016   return jresult;
30017 }
30018
30019
30020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30021   void * jresult ;
30022   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30023   std::size_t arg2 ;
30024   Dali::Actor result;
30025
30026   arg1 = (Dali::TouchData *)jarg1;
30027   arg2 = (std::size_t)jarg2;
30028   {
30029     try {
30030       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30031     } catch (std::out_of_range& e) {
30032       {
30033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30034       };
30035     } catch (std::exception& e) {
30036       {
30037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30038       };
30039     } catch (Dali::DaliException e) {
30040       {
30041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30042       };
30043     } catch (...) {
30044       {
30045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30046       };
30047     }
30048   }
30049
30050   jresult = new Dali::Actor((const Dali::Actor &)result);
30051   return jresult;
30052 }
30053
30054
30055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30056   void * jresult ;
30057   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30058   std::size_t arg2 ;
30059   Dali::Vector2 *result = 0 ;
30060
30061   arg1 = (Dali::TouchData *)jarg1;
30062   arg2 = (std::size_t)jarg2;
30063   {
30064     try {
30065       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30066     } catch (std::out_of_range& e) {
30067       {
30068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30069       };
30070     } catch (std::exception& e) {
30071       {
30072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30073       };
30074     } catch (Dali::DaliException e) {
30075       {
30076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30077       };
30078     } catch (...) {
30079       {
30080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30081       };
30082     }
30083   }
30084
30085   jresult = (void *)result;
30086   return jresult;
30087 }
30088
30089
30090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30091   void * jresult ;
30092   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30093   std::size_t arg2 ;
30094   Dali::Vector2 *result = 0 ;
30095
30096   arg1 = (Dali::TouchData *)jarg1;
30097   arg2 = (std::size_t)jarg2;
30098   {
30099     try {
30100       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30101     } catch (std::out_of_range& e) {
30102       {
30103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30104       };
30105     } catch (std::exception& e) {
30106       {
30107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30108       };
30109     } catch (Dali::DaliException e) {
30110       {
30111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30112       };
30113     } catch (...) {
30114       {
30115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30116       };
30117     }
30118   }
30119
30120   jresult = (void *)result;
30121   return jresult;
30122 }
30123
30124
30125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30126   float jresult ;
30127   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30128   std::size_t arg2 ;
30129   float result;
30130
30131   arg1 = (Dali::TouchData *)jarg1;
30132   arg2 = (std::size_t)jarg2;
30133   {
30134     try {
30135       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30136     } catch (std::out_of_range& e) {
30137       {
30138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30139       };
30140     } catch (std::exception& e) {
30141       {
30142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30143       };
30144     } catch (Dali::DaliException e) {
30145       {
30146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30147       };
30148     } catch (...) {
30149       {
30150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30151       };
30152     }
30153   }
30154
30155   jresult = result;
30156   return jresult;
30157 }
30158
30159
30160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30161   void * jresult ;
30162   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30163   std::size_t arg2 ;
30164   Dali::Vector2 *result = 0 ;
30165
30166   arg1 = (Dali::TouchData *)jarg1;
30167   arg2 = (std::size_t)jarg2;
30168   {
30169     try {
30170       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30171     } catch (std::out_of_range& e) {
30172       {
30173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30174       };
30175     } catch (std::exception& e) {
30176       {
30177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30178       };
30179     } catch (Dali::DaliException e) {
30180       {
30181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30182       };
30183     } catch (...) {
30184       {
30185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30186       };
30187     }
30188   }
30189
30190   jresult = (void *)result;
30191   return jresult;
30192 }
30193
30194
30195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30196   float jresult ;
30197   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30198   std::size_t arg2 ;
30199   float result;
30200
30201   arg1 = (Dali::TouchData *)jarg1;
30202   arg2 = (std::size_t)jarg2;
30203   {
30204     try {
30205       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30206     } catch (std::out_of_range& e) {
30207       {
30208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30209       };
30210     } catch (std::exception& e) {
30211       {
30212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30213       };
30214     } catch (Dali::DaliException e) {
30215       {
30216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30217       };
30218     } catch (...) {
30219       {
30220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30221       };
30222     }
30223   }
30224
30225   jresult = result;
30226   return jresult;
30227 }
30228
30229
30230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30231   void * jresult ;
30232   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30233   std::size_t arg2 ;
30234   Dali::Degree result;
30235
30236   arg1 = (Dali::TouchData *)jarg1;
30237   arg2 = (std::size_t)jarg2;
30238   {
30239     try {
30240       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30241     } catch (std::out_of_range& e) {
30242       {
30243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30244       };
30245     } catch (std::exception& e) {
30246       {
30247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30248       };
30249     } catch (Dali::DaliException e) {
30250       {
30251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30252       };
30253     } catch (...) {
30254       {
30255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30256       };
30257     }
30258   }
30259
30260   jresult = new Dali::Degree((const Dali::Degree &)result);
30261   return jresult;
30262 }
30263
30264
30265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30266   int jresult ;
30267   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30268   std::size_t arg2 ;
30269   Dali::MouseButton::Type result;
30270
30271   arg1 = (Dali::TouchData *)jarg1;
30272   arg2 = (std::size_t)jarg2;
30273   {
30274     try {
30275       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30276     } catch (std::out_of_range& e) {
30277       {
30278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30279       };
30280     } catch (std::exception& e) {
30281       {
30282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30283       };
30284     } catch (Dali::DaliException e) {
30285       {
30286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30287       };
30288     } catch (...) {
30289       {
30290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30291       };
30292     }
30293   }
30294
30295   jresult = static_cast< int >(result);
30296   return jresult;
30297 }
30298
30299
30300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30301   void * jresult ;
30302   Dali::GestureDetector *result = 0 ;
30303
30304   {
30305     try {
30306       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30307     } catch (std::out_of_range& e) {
30308       {
30309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30310       };
30311     } catch (std::exception& e) {
30312       {
30313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30314       };
30315     } catch (Dali::DaliException e) {
30316       {
30317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30318       };
30319     } catch (...) {
30320       {
30321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30322       };
30323     }
30324   }
30325
30326   jresult = (void *)result;
30327   return jresult;
30328 }
30329
30330
30331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30332   void * jresult ;
30333   Dali::BaseHandle arg1 ;
30334   Dali::BaseHandle *argp1 ;
30335   Dali::GestureDetector result;
30336
30337   argp1 = (Dali::BaseHandle *)jarg1;
30338   if (!argp1) {
30339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30340     return 0;
30341   }
30342   arg1 = *argp1;
30343   {
30344     try {
30345       result = Dali::GestureDetector::DownCast(arg1);
30346     } catch (std::out_of_range& e) {
30347       {
30348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30349       };
30350     } catch (std::exception& e) {
30351       {
30352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30353       };
30354     } catch (Dali::DaliException e) {
30355       {
30356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30357       };
30358     } catch (...) {
30359       {
30360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30361       };
30362     }
30363   }
30364
30365   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30366   return jresult;
30367 }
30368
30369
30370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30371   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30372
30373   arg1 = (Dali::GestureDetector *)jarg1;
30374   {
30375     try {
30376       delete arg1;
30377     } catch (std::out_of_range& e) {
30378       {
30379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30380       };
30381     } catch (std::exception& e) {
30382       {
30383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30384       };
30385     } catch (Dali::DaliException e) {
30386       {
30387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30388       };
30389     } catch (...) {
30390       {
30391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30392       };
30393     }
30394   }
30395
30396 }
30397
30398
30399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30400   void * jresult ;
30401   Dali::GestureDetector *arg1 = 0 ;
30402   Dali::GestureDetector *result = 0 ;
30403
30404   arg1 = (Dali::GestureDetector *)jarg1;
30405   if (!arg1) {
30406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30407     return 0;
30408   }
30409   {
30410     try {
30411       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30412     } catch (std::out_of_range& e) {
30413       {
30414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30415       };
30416     } catch (std::exception& e) {
30417       {
30418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30419       };
30420     } catch (Dali::DaliException e) {
30421       {
30422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30423       };
30424     } catch (...) {
30425       {
30426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30427       };
30428     }
30429   }
30430
30431   jresult = (void *)result;
30432   return jresult;
30433 }
30434
30435
30436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30437   void * jresult ;
30438   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30439   Dali::GestureDetector *arg2 = 0 ;
30440   Dali::GestureDetector *result = 0 ;
30441
30442   arg1 = (Dali::GestureDetector *)jarg1;
30443   arg2 = (Dali::GestureDetector *)jarg2;
30444   if (!arg2) {
30445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30446     return 0;
30447   }
30448   {
30449     try {
30450       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30451     } catch (std::out_of_range& e) {
30452       {
30453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30454       };
30455     } catch (std::exception& e) {
30456       {
30457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30458       };
30459     } catch (Dali::DaliException e) {
30460       {
30461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30462       };
30463     } catch (...) {
30464       {
30465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30466       };
30467     }
30468   }
30469
30470   jresult = (void *)result;
30471   return jresult;
30472 }
30473
30474
30475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30476   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30477   Dali::Actor arg2 ;
30478   Dali::Actor *argp2 ;
30479
30480   arg1 = (Dali::GestureDetector *)jarg1;
30481   argp2 = (Dali::Actor *)jarg2;
30482   if (!argp2) {
30483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30484     return ;
30485   }
30486   arg2 = *argp2;
30487   {
30488     try {
30489       (arg1)->Attach(arg2);
30490     } catch (std::out_of_range& e) {
30491       {
30492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30493       };
30494     } catch (std::exception& e) {
30495       {
30496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30497       };
30498     } catch (Dali::DaliException e) {
30499       {
30500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30501       };
30502     } catch (...) {
30503       {
30504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30505       };
30506     }
30507   }
30508
30509 }
30510
30511
30512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30513   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30514   Dali::Actor arg2 ;
30515   Dali::Actor *argp2 ;
30516
30517   arg1 = (Dali::GestureDetector *)jarg1;
30518   argp2 = (Dali::Actor *)jarg2;
30519   if (!argp2) {
30520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30521     return ;
30522   }
30523   arg2 = *argp2;
30524   {
30525     try {
30526       (arg1)->Detach(arg2);
30527     } catch (std::out_of_range& e) {
30528       {
30529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30530       };
30531     } catch (std::exception& e) {
30532       {
30533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30534       };
30535     } catch (Dali::DaliException e) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30538       };
30539     } catch (...) {
30540       {
30541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30542       };
30543     }
30544   }
30545
30546 }
30547
30548
30549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30550   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30551
30552   arg1 = (Dali::GestureDetector *)jarg1;
30553   {
30554     try {
30555       (arg1)->DetachAll();
30556     } catch (std::out_of_range& e) {
30557       {
30558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30559       };
30560     } catch (std::exception& e) {
30561       {
30562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30563       };
30564     } catch (Dali::DaliException e) {
30565       {
30566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30567       };
30568     } catch (...) {
30569       {
30570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30571       };
30572     }
30573   }
30574
30575 }
30576
30577
30578 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30579   unsigned long jresult ;
30580   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30581   size_t result;
30582
30583   arg1 = (Dali::GestureDetector *)jarg1;
30584   {
30585     try {
30586       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30587     } catch (std::out_of_range& e) {
30588       {
30589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30590       };
30591     } catch (std::exception& e) {
30592       {
30593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30594       };
30595     } catch (Dali::DaliException e) {
30596       {
30597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30598       };
30599     } catch (...) {
30600       {
30601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30602       };
30603     }
30604   }
30605
30606   jresult = (unsigned long)result;
30607   return jresult;
30608 }
30609
30610
30611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30612   void * jresult ;
30613   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30614   size_t arg2 ;
30615   Dali::Actor result;
30616
30617   arg1 = (Dali::GestureDetector *)jarg1;
30618   arg2 = (size_t)jarg2;
30619   {
30620     try {
30621       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30622     } catch (std::out_of_range& e) {
30623       {
30624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30625       };
30626     } catch (std::exception& e) {
30627       {
30628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30629       };
30630     } catch (Dali::DaliException e) {
30631       {
30632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30633       };
30634     } catch (...) {
30635       {
30636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30637       };
30638     }
30639   }
30640
30641   jresult = new Dali::Actor((const Dali::Actor &)result);
30642   return jresult;
30643 }
30644
30645
30646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30647   void * jresult ;
30648   Dali::Gesture *arg1 = 0 ;
30649   Dali::Gesture *result = 0 ;
30650
30651   arg1 = (Dali::Gesture *)jarg1;
30652   if (!arg1) {
30653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30654     return 0;
30655   }
30656   {
30657     try {
30658       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30659     } catch (std::out_of_range& e) {
30660       {
30661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30662       };
30663     } catch (std::exception& e) {
30664       {
30665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30666       };
30667     } catch (Dali::DaliException e) {
30668       {
30669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30670       };
30671     } catch (...) {
30672       {
30673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30674       };
30675     }
30676   }
30677
30678   jresult = (void *)result;
30679   return jresult;
30680 }
30681
30682
30683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30684   void * jresult ;
30685   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30686   Dali::Gesture *arg2 = 0 ;
30687   Dali::Gesture *result = 0 ;
30688
30689   arg1 = (Dali::Gesture *)jarg1;
30690   arg2 = (Dali::Gesture *)jarg2;
30691   if (!arg2) {
30692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30693     return 0;
30694   }
30695   {
30696     try {
30697       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30698     } catch (std::out_of_range& e) {
30699       {
30700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30701       };
30702     } catch (std::exception& e) {
30703       {
30704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30705       };
30706     } catch (Dali::DaliException e) {
30707       {
30708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30709       };
30710     } catch (...) {
30711       {
30712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30713       };
30714     }
30715   }
30716
30717   jresult = (void *)result;
30718   return jresult;
30719 }
30720
30721
30722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30723   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30724
30725   arg1 = (Dali::Gesture *)jarg1;
30726   {
30727     try {
30728       delete arg1;
30729     } catch (std::out_of_range& e) {
30730       {
30731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30732       };
30733     } catch (std::exception& e) {
30734       {
30735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30736       };
30737     } catch (Dali::DaliException e) {
30738       {
30739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30740       };
30741     } catch (...) {
30742       {
30743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30744       };
30745     }
30746   }
30747
30748 }
30749
30750
30751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30752   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30753   Dali::Gesture::Type arg2 ;
30754
30755   arg1 = (Dali::Gesture *)jarg1;
30756   arg2 = (Dali::Gesture::Type)jarg2;
30757   if (arg1) (arg1)->type = arg2;
30758 }
30759
30760
30761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30762   int jresult ;
30763   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30764   Dali::Gesture::Type result;
30765
30766   arg1 = (Dali::Gesture *)jarg1;
30767   result = (Dali::Gesture::Type) ((arg1)->type);
30768   jresult = (int)result;
30769   return jresult;
30770 }
30771
30772
30773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30774   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30775   Dali::Gesture::State arg2 ;
30776
30777   arg1 = (Dali::Gesture *)jarg1;
30778   arg2 = (Dali::Gesture::State)jarg2;
30779   if (arg1) (arg1)->state = arg2;
30780 }
30781
30782
30783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30784   int jresult ;
30785   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30786   Dali::Gesture::State result;
30787
30788   arg1 = (Dali::Gesture *)jarg1;
30789   result = (Dali::Gesture::State) ((arg1)->state);
30790   jresult = (int)result;
30791   return jresult;
30792 }
30793
30794
30795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30796   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30797   unsigned int arg2 ;
30798
30799   arg1 = (Dali::Gesture *)jarg1;
30800   arg2 = (unsigned int)jarg2;
30801   if (arg1) (arg1)->time = arg2;
30802 }
30803
30804
30805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30806   unsigned int jresult ;
30807   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30808   unsigned int result;
30809
30810   arg1 = (Dali::Gesture *)jarg1;
30811   result = (unsigned int) ((arg1)->time);
30812   jresult = result;
30813   return jresult;
30814 }
30815
30816
30817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30818   void * jresult ;
30819   Dali::HoverEvent *result = 0 ;
30820
30821   {
30822     try {
30823       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30824     } catch (std::out_of_range& e) {
30825       {
30826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30827       };
30828     } catch (std::exception& e) {
30829       {
30830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30831       };
30832     } catch (Dali::DaliException e) {
30833       {
30834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30835       };
30836     } catch (...) {
30837       {
30838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30839       };
30840     }
30841   }
30842
30843   jresult = (void *)result;
30844   return jresult;
30845 }
30846
30847
30848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30849   void * jresult ;
30850   unsigned long arg1 ;
30851   Dali::HoverEvent *result = 0 ;
30852
30853   arg1 = (unsigned long)jarg1;
30854   {
30855     try {
30856       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30857     } catch (std::out_of_range& e) {
30858       {
30859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30860       };
30861     } catch (std::exception& e) {
30862       {
30863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30864       };
30865     } catch (Dali::DaliException e) {
30866       {
30867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30868       };
30869     } catch (...) {
30870       {
30871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30872       };
30873     }
30874   }
30875
30876   jresult = (void *)result;
30877   return jresult;
30878 }
30879
30880
30881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30882   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30883
30884   arg1 = (Dali::HoverEvent *)jarg1;
30885   {
30886     try {
30887       delete arg1;
30888     } catch (std::out_of_range& e) {
30889       {
30890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30891       };
30892     } catch (std::exception& e) {
30893       {
30894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30895       };
30896     } catch (Dali::DaliException e) {
30897       {
30898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30899       };
30900     } catch (...) {
30901       {
30902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30903       };
30904     }
30905   }
30906
30907 }
30908
30909
30910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30911   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30912   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30913
30914   arg1 = (Dali::HoverEvent *)jarg1;
30915   arg2 = (Dali::TouchPointContainer *)jarg2;
30916   if (arg1) (arg1)->points = *arg2;
30917 }
30918
30919
30920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30921   void * jresult ;
30922   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30923   Dali::TouchPointContainer *result = 0 ;
30924
30925   arg1 = (Dali::HoverEvent *)jarg1;
30926   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30927   jresult = (void *)result;
30928   return jresult;
30929 }
30930
30931
30932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30933   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30934   unsigned long arg2 ;
30935
30936   arg1 = (Dali::HoverEvent *)jarg1;
30937   arg2 = (unsigned long)jarg2;
30938   if (arg1) (arg1)->time = arg2;
30939 }
30940
30941
30942 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30943   unsigned long jresult ;
30944   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30945   unsigned long result;
30946
30947   arg1 = (Dali::HoverEvent *)jarg1;
30948   result = (unsigned long) ((arg1)->time);
30949   jresult = (unsigned long)result;
30950   return jresult;
30951 }
30952
30953
30954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30955   unsigned int jresult ;
30956   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30957   unsigned int result;
30958
30959   arg1 = (Dali::HoverEvent *)jarg1;
30960   {
30961     try {
30962       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30963     } catch (std::out_of_range& e) {
30964       {
30965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30966       };
30967     } catch (std::exception& e) {
30968       {
30969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30970       };
30971     } catch (Dali::DaliException e) {
30972       {
30973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30974       };
30975     } catch (...) {
30976       {
30977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30978       };
30979     }
30980   }
30981
30982   jresult = result;
30983   return jresult;
30984 }
30985
30986
30987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30988   void * jresult ;
30989   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30990   unsigned int arg2 ;
30991   Dali::TouchPoint *result = 0 ;
30992
30993   arg1 = (Dali::HoverEvent *)jarg1;
30994   arg2 = (unsigned int)jarg2;
30995   {
30996     try {
30997       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30998     } catch (std::out_of_range& e) {
30999       {
31000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31001       };
31002     } catch (std::exception& e) {
31003       {
31004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31005       };
31006     } catch (Dali::DaliException e) {
31007       {
31008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31009       };
31010     } catch (...) {
31011       {
31012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31013       };
31014     }
31015   }
31016
31017   jresult = (void *)result;
31018   return jresult;
31019 }
31020
31021
31022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31023   void * jresult ;
31024   Dali::KeyEvent *result = 0 ;
31025
31026   {
31027     try {
31028       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31029     } catch (std::out_of_range& e) {
31030       {
31031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31032       };
31033     } catch (std::exception& e) {
31034       {
31035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31036       };
31037     } catch (Dali::DaliException e) {
31038       {
31039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31040       };
31041     } catch (...) {
31042       {
31043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31044       };
31045     }
31046   }
31047
31048   jresult = (void *)result;
31049   return jresult;
31050 }
31051
31052
31053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31054   void * jresult ;
31055   std::string *arg1 = 0 ;
31056   std::string *arg2 = 0 ;
31057   int arg3 ;
31058   int arg4 ;
31059   unsigned long arg5 ;
31060   Dali::KeyEvent::State *arg6 = 0 ;
31061   Dali::KeyEvent::State temp6 ;
31062   Dali::KeyEvent *result = 0 ;
31063
31064   if (!jarg1) {
31065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31066     return 0;
31067   }
31068   std::string arg1_str(jarg1);
31069   arg1 = &arg1_str;
31070   if (!jarg2) {
31071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31072     return 0;
31073   }
31074   std::string arg2_str(jarg2);
31075   arg2 = &arg2_str;
31076   arg3 = (int)jarg3;
31077   arg4 = (int)jarg4;
31078   arg5 = (unsigned long)jarg5;
31079   temp6 = (Dali::KeyEvent::State)jarg6;
31080   arg6 = &temp6;
31081   {
31082     try {
31083       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31084     } catch (std::out_of_range& e) {
31085       {
31086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31087       };
31088     } catch (std::exception& e) {
31089       {
31090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31091       };
31092     } catch (Dali::DaliException e) {
31093       {
31094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31095       };
31096     } catch (...) {
31097       {
31098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31099       };
31100     }
31101   }
31102
31103   jresult = (void *)result;
31104
31105   //argout typemap for const std::string&
31106
31107
31108   //argout typemap for const std::string&
31109
31110   return jresult;
31111 }
31112
31113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31114   void * jresult ;
31115   Dali::KeyEvent *arg1 = 0 ;
31116   Dali::KeyEvent *result = 0 ;
31117
31118   arg1 = (Dali::KeyEvent *)jarg1;
31119   if (!arg1) {
31120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31121     return 0;
31122   }
31123   {
31124     try {
31125       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31126     } catch (std::out_of_range& e) {
31127       {
31128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31129       };
31130     } catch (std::exception& e) {
31131       {
31132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31133       };
31134     } catch (Dali::DaliException e) {
31135       {
31136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31137       };
31138     } catch (...) {
31139       {
31140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31141       };
31142     }
31143   }
31144
31145   jresult = (void *)result;
31146   return jresult;
31147 }
31148
31149
31150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31151   void * jresult ;
31152   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31153   Dali::KeyEvent *arg2 = 0 ;
31154   Dali::KeyEvent *result = 0 ;
31155
31156   arg1 = (Dali::KeyEvent *)jarg1;
31157   arg2 = (Dali::KeyEvent *)jarg2;
31158   if (!arg2) {
31159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31160     return 0;
31161   }
31162   {
31163     try {
31164       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31165     } catch (std::out_of_range& e) {
31166       {
31167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31168       };
31169     } catch (std::exception& e) {
31170       {
31171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31172       };
31173     } catch (Dali::DaliException e) {
31174       {
31175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31176       };
31177     } catch (...) {
31178       {
31179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31180       };
31181     }
31182   }
31183
31184   jresult = (void *)result;
31185   return jresult;
31186 }
31187
31188
31189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31190   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31191
31192   arg1 = (Dali::KeyEvent *)jarg1;
31193   {
31194     try {
31195       delete arg1;
31196     } catch (std::out_of_range& e) {
31197       {
31198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31199       };
31200     } catch (std::exception& e) {
31201       {
31202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31203       };
31204     } catch (Dali::DaliException e) {
31205       {
31206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31207       };
31208     } catch (...) {
31209       {
31210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31211       };
31212     }
31213   }
31214
31215 }
31216
31217
31218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31219   unsigned int jresult ;
31220   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31221   bool result;
31222
31223   arg1 = (Dali::KeyEvent *)jarg1;
31224   {
31225     try {
31226       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31227     } catch (std::out_of_range& e) {
31228       {
31229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31230       };
31231     } catch (std::exception& e) {
31232       {
31233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31234       };
31235     } catch (Dali::DaliException e) {
31236       {
31237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31238       };
31239     } catch (...) {
31240       {
31241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31242       };
31243     }
31244   }
31245
31246   jresult = result;
31247   return jresult;
31248 }
31249
31250
31251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31252   unsigned int jresult ;
31253   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31254   bool result;
31255
31256   arg1 = (Dali::KeyEvent *)jarg1;
31257   {
31258     try {
31259       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31260     } catch (std::out_of_range& e) {
31261       {
31262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31263       };
31264     } catch (std::exception& e) {
31265       {
31266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31267       };
31268     } catch (Dali::DaliException e) {
31269       {
31270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31271       };
31272     } catch (...) {
31273       {
31274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31275       };
31276     }
31277   }
31278
31279   jresult = result;
31280   return jresult;
31281 }
31282
31283
31284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31285   unsigned int jresult ;
31286   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31287   bool result;
31288
31289   arg1 = (Dali::KeyEvent *)jarg1;
31290   {
31291     try {
31292       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31293     } catch (std::out_of_range& e) {
31294       {
31295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31296       };
31297     } catch (std::exception& e) {
31298       {
31299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31300       };
31301     } catch (Dali::DaliException e) {
31302       {
31303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31304       };
31305     } catch (...) {
31306       {
31307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31308       };
31309     }
31310   }
31311
31312   jresult = result;
31313   return jresult;
31314 }
31315
31316
31317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31318   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31319   std::string *arg2 = 0 ;
31320
31321   arg1 = (Dali::KeyEvent *)jarg1;
31322   if (!jarg2) {
31323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31324     return ;
31325   }
31326   std::string arg2_str(jarg2);
31327   arg2 = &arg2_str;
31328   if (arg1) (arg1)->keyPressedName = *arg2;
31329
31330   //argout typemap for const std::string&
31331
31332 }
31333
31334
31335 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31336   char * jresult ;
31337
31338   if( jarg1 == NULL )
31339   {
31340     jresult = SWIG_csharp_string_callback( "" );
31341   }
31342   else
31343   {
31344     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31345     std::string *result = 0;
31346
31347     arg1 = ( Dali::KeyEvent * )jarg1;
31348     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31349     jresult = SWIG_csharp_string_callback( result->c_str() );
31350   }
31351
31352   return jresult;
31353 }
31354
31355
31356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31357   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31358   std::string *arg2 = 0 ;
31359
31360   arg1 = (Dali::KeyEvent *)jarg1;
31361   if (!jarg2) {
31362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31363     return ;
31364   }
31365   std::string arg2_str(jarg2);
31366   arg2 = &arg2_str;
31367   if (arg1) (arg1)->keyPressed = *arg2;
31368
31369   //argout typemap for const std::string&
31370
31371 }
31372
31373
31374 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31375   char * jresult ;
31376   if( NULL == jarg1 )
31377   {
31378     jresult = SWIG_csharp_string_callback( "" );
31379   }
31380   else
31381   {
31382     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31383     std::string *result = 0;
31384
31385     arg1 = ( Dali::KeyEvent * )jarg1;
31386     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31387     jresult = SWIG_csharp_string_callback( result->c_str() );
31388   }
31389   return jresult;
31390 }
31391
31392
31393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31394   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31395   int arg2 ;
31396
31397   arg1 = (Dali::KeyEvent *)jarg1;
31398   arg2 = (int)jarg2;
31399   if (arg1) (arg1)->keyCode = arg2;
31400 }
31401
31402
31403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31404   int jresult ;
31405   if( NULL == jarg1 )
31406   {
31407     jresult = -1;
31408   }
31409   else
31410   {
31411     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31412     int result;
31413
31414     arg1 = ( Dali::KeyEvent * )jarg1;
31415     result = (int)( ( arg1 )->keyCode );
31416     jresult = result;
31417   }
31418   return jresult;
31419 }
31420
31421
31422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31423   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31424   int arg2 ;
31425
31426   arg1 = (Dali::KeyEvent *)jarg1;
31427   arg2 = (int)jarg2;
31428   if (arg1) (arg1)->keyModifier = arg2;
31429 }
31430
31431
31432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31433   int jresult ;
31434   if( jarg1 == NULL )
31435   {
31436     jresult = -1;
31437   }
31438   else
31439   {
31440     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31441     int result;
31442
31443     arg1 = ( Dali::KeyEvent * )jarg1;
31444     result = (int)( ( arg1 )->keyModifier );
31445     jresult = result;
31446   }
31447   return jresult;
31448 }
31449
31450
31451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31452   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31453   unsigned long arg2 ;
31454
31455   arg1 = (Dali::KeyEvent *)jarg1;
31456   arg2 = (unsigned long)jarg2;
31457   if (arg1) (arg1)->time = arg2;
31458 }
31459
31460
31461 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31462   unsigned long jresult ;
31463   if( jarg1 == NULL )
31464   {
31465     jresult = 0;
31466   }
31467   else
31468   {
31469     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31470     unsigned long result;
31471
31472     arg1 = ( Dali::KeyEvent * )jarg1;
31473     result = (unsigned long)( ( arg1 )->time );
31474     jresult = (unsigned long)result;
31475   }
31476   return jresult;
31477 }
31478
31479
31480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31481   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31482   Dali::KeyEvent::State arg2 ;
31483
31484   arg1 = (Dali::KeyEvent *)jarg1;
31485   arg2 = (Dali::KeyEvent::State)jarg2;
31486   if (arg1) (arg1)->state = arg2;
31487 }
31488
31489
31490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31491   int jresult ;
31492   if( jarg1 == NULL )
31493   {
31494     jresult = -1;
31495   }
31496   else
31497   {
31498     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31499     Dali::KeyEvent::State result;
31500
31501     arg1 = ( Dali::KeyEvent * )jarg1;
31502     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31503     jresult = (int)result;
31504   }
31505   return jresult;
31506 }
31507
31508 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31509   char * jresult ;
31510   std::string result;
31511   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31512
31513   arg1 = (Dali::KeyEvent *)jarg1;
31514   if (!arg1) {
31515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31516     return 0;
31517   }
31518   {
31519     try {
31520       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31521     } catch (std::out_of_range& e) {
31522       {
31523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31524       };
31525     } catch (std::exception& e) {
31526       {
31527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31528       };
31529     } catch (Dali::DaliException e) {
31530       {
31531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31532       };
31533     } catch (...) {
31534       {
31535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31536       };
31537     }
31538
31539   }
31540
31541   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31542   return jresult;
31543 }
31544
31545
31546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31547   void * jresult ;
31548   Dali::LongPressGestureDetector *result = 0 ;
31549
31550   {
31551     try {
31552       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31553     } catch (std::out_of_range& e) {
31554       {
31555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31556       };
31557     } catch (std::exception& e) {
31558       {
31559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31560       };
31561     } catch (Dali::DaliException e) {
31562       {
31563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31564       };
31565     } catch (...) {
31566       {
31567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31568       };
31569     }
31570   }
31571
31572   jresult = (void *)result;
31573   return jresult;
31574 }
31575
31576
31577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31578   void * jresult ;
31579   Dali::LongPressGestureDetector result;
31580
31581   {
31582     try {
31583       result = Dali::LongPressGestureDetector::New();
31584     } catch (std::out_of_range& e) {
31585       {
31586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31587       };
31588     } catch (std::exception& e) {
31589       {
31590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31591       };
31592     } catch (Dali::DaliException e) {
31593       {
31594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31595       };
31596     } catch (...) {
31597       {
31598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31599       };
31600     }
31601   }
31602
31603   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31604   return jresult;
31605 }
31606
31607
31608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31609   void * jresult ;
31610   unsigned int arg1 ;
31611   Dali::LongPressGestureDetector result;
31612
31613   arg1 = (unsigned int)jarg1;
31614   {
31615     try {
31616       result = Dali::LongPressGestureDetector::New(arg1);
31617     } catch (std::out_of_range& e) {
31618       {
31619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31620       };
31621     } catch (std::exception& e) {
31622       {
31623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31624       };
31625     } catch (Dali::DaliException e) {
31626       {
31627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31628       };
31629     } catch (...) {
31630       {
31631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31632       };
31633     }
31634   }
31635
31636   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31637   return jresult;
31638 }
31639
31640
31641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31642   void * jresult ;
31643   unsigned int arg1 ;
31644   unsigned int arg2 ;
31645   Dali::LongPressGestureDetector result;
31646
31647   arg1 = (unsigned int)jarg1;
31648   arg2 = (unsigned int)jarg2;
31649   {
31650     try {
31651       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31652     } catch (std::out_of_range& e) {
31653       {
31654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31655       };
31656     } catch (std::exception& e) {
31657       {
31658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31659       };
31660     } catch (Dali::DaliException e) {
31661       {
31662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31663       };
31664     } catch (...) {
31665       {
31666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31667       };
31668     }
31669   }
31670
31671   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31672   return jresult;
31673 }
31674
31675
31676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31677   void * jresult ;
31678   Dali::BaseHandle arg1 ;
31679   Dali::BaseHandle *argp1 ;
31680   Dali::LongPressGestureDetector result;
31681
31682   argp1 = (Dali::BaseHandle *)jarg1;
31683   if (!argp1) {
31684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31685     return 0;
31686   }
31687   arg1 = *argp1;
31688   {
31689     try {
31690       result = Dali::LongPressGestureDetector::DownCast(arg1);
31691     } catch (std::out_of_range& e) {
31692       {
31693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31694       };
31695     } catch (std::exception& e) {
31696       {
31697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31698       };
31699     } catch (Dali::DaliException e) {
31700       {
31701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31706       };
31707     }
31708   }
31709
31710   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31711   return jresult;
31712 }
31713
31714
31715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31716   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31717
31718   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31719   {
31720     try {
31721       delete arg1;
31722     } catch (std::out_of_range& e) {
31723       {
31724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31725       };
31726     } catch (std::exception& e) {
31727       {
31728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31729       };
31730     } catch (Dali::DaliException e) {
31731       {
31732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31733       };
31734     } catch (...) {
31735       {
31736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31737       };
31738     }
31739   }
31740
31741 }
31742
31743
31744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31745   void * jresult ;
31746   Dali::LongPressGestureDetector *arg1 = 0 ;
31747   Dali::LongPressGestureDetector *result = 0 ;
31748
31749   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31750   if (!arg1) {
31751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31752     return 0;
31753   }
31754   {
31755     try {
31756       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31757     } catch (std::out_of_range& e) {
31758       {
31759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31760       };
31761     } catch (std::exception& e) {
31762       {
31763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31764       };
31765     } catch (Dali::DaliException e) {
31766       {
31767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31768       };
31769     } catch (...) {
31770       {
31771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31772       };
31773     }
31774   }
31775
31776   jresult = (void *)result;
31777   return jresult;
31778 }
31779
31780
31781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31782   void * jresult ;
31783   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31784   Dali::LongPressGestureDetector *arg2 = 0 ;
31785   Dali::LongPressGestureDetector *result = 0 ;
31786
31787   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31788   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31789   if (!arg2) {
31790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31791     return 0;
31792   }
31793   {
31794     try {
31795       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31796     } catch (std::out_of_range& e) {
31797       {
31798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31799       };
31800     } catch (std::exception& e) {
31801       {
31802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31803       };
31804     } catch (Dali::DaliException e) {
31805       {
31806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31807       };
31808     } catch (...) {
31809       {
31810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31811       };
31812     }
31813   }
31814
31815   jresult = (void *)result;
31816   return jresult;
31817 }
31818
31819
31820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31821   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31822   unsigned int arg2 ;
31823
31824   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31825   arg2 = (unsigned int)jarg2;
31826   {
31827     try {
31828       (arg1)->SetTouchesRequired(arg2);
31829     } catch (std::out_of_range& e) {
31830       {
31831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31832       };
31833     } catch (std::exception& e) {
31834       {
31835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31836       };
31837     } catch (Dali::DaliException e) {
31838       {
31839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31840       };
31841     } catch (...) {
31842       {
31843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31844       };
31845     }
31846   }
31847
31848 }
31849
31850
31851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31852   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31853   unsigned int arg2 ;
31854   unsigned int arg3 ;
31855
31856   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31857   arg2 = (unsigned int)jarg2;
31858   arg3 = (unsigned int)jarg3;
31859   {
31860     try {
31861       (arg1)->SetTouchesRequired(arg2,arg3);
31862     } catch (std::out_of_range& e) {
31863       {
31864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31865       };
31866     } catch (std::exception& e) {
31867       {
31868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31869       };
31870     } catch (Dali::DaliException e) {
31871       {
31872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31873       };
31874     } catch (...) {
31875       {
31876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31877       };
31878     }
31879   }
31880
31881 }
31882
31883
31884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31885   unsigned int jresult ;
31886   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31887   unsigned int result;
31888
31889   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31890   {
31891     try {
31892       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31893     } catch (std::out_of_range& e) {
31894       {
31895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31896       };
31897     } catch (std::exception& e) {
31898       {
31899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (Dali::DaliException e) {
31902       {
31903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31904       };
31905     } catch (...) {
31906       {
31907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31908       };
31909     }
31910   }
31911
31912   jresult = result;
31913   return jresult;
31914 }
31915
31916
31917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31918   unsigned int jresult ;
31919   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31920   unsigned int result;
31921
31922   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31923   {
31924     try {
31925       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31926     } catch (std::out_of_range& e) {
31927       {
31928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31929       };
31930     } catch (std::exception& e) {
31931       {
31932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31933       };
31934     } catch (Dali::DaliException e) {
31935       {
31936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31937       };
31938     } catch (...) {
31939       {
31940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31941       };
31942     }
31943   }
31944
31945   jresult = result;
31946   return jresult;
31947 }
31948
31949
31950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31951   void * jresult ;
31952   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31953   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31954
31955   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31956   {
31957     try {
31958       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31959     } catch (std::out_of_range& e) {
31960       {
31961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31962       };
31963     } catch (std::exception& e) {
31964       {
31965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31966       };
31967     } catch (Dali::DaliException e) {
31968       {
31969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31970       };
31971     } catch (...) {
31972       {
31973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31974       };
31975     }
31976   }
31977
31978   jresult = (void *)result;
31979   return jresult;
31980 }
31981
31982
31983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31984   void * jresult ;
31985   Dali::Gesture::State arg1 ;
31986   Dali::LongPressGesture *result = 0 ;
31987
31988   arg1 = (Dali::Gesture::State)jarg1;
31989   {
31990     try {
31991       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31992     } catch (std::out_of_range& e) {
31993       {
31994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31995       };
31996     } catch (std::exception& e) {
31997       {
31998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31999       };
32000     } catch (Dali::DaliException e) {
32001       {
32002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32003       };
32004     } catch (...) {
32005       {
32006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32007       };
32008     }
32009   }
32010
32011   jresult = (void *)result;
32012   return jresult;
32013 }
32014
32015
32016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32017   void * jresult ;
32018   Dali::LongPressGesture *arg1 = 0 ;
32019   Dali::LongPressGesture *result = 0 ;
32020
32021   arg1 = (Dali::LongPressGesture *)jarg1;
32022   if (!arg1) {
32023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32024     return 0;
32025   }
32026   {
32027     try {
32028       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32029     } catch (std::out_of_range& e) {
32030       {
32031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32032       };
32033     } catch (std::exception& e) {
32034       {
32035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32036       };
32037     } catch (Dali::DaliException e) {
32038       {
32039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32040       };
32041     } catch (...) {
32042       {
32043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32044       };
32045     }
32046   }
32047
32048   jresult = (void *)result;
32049   return jresult;
32050 }
32051
32052
32053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32054   void * jresult ;
32055   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32056   Dali::LongPressGesture *arg2 = 0 ;
32057   Dali::LongPressGesture *result = 0 ;
32058
32059   arg1 = (Dali::LongPressGesture *)jarg1;
32060   arg2 = (Dali::LongPressGesture *)jarg2;
32061   if (!arg2) {
32062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32063     return 0;
32064   }
32065   {
32066     try {
32067       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32068     } catch (std::out_of_range& e) {
32069       {
32070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32071       };
32072     } catch (std::exception& e) {
32073       {
32074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32075       };
32076     } catch (Dali::DaliException e) {
32077       {
32078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32079       };
32080     } catch (...) {
32081       {
32082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32083       };
32084     }
32085   }
32086
32087   jresult = (void *)result;
32088   return jresult;
32089 }
32090
32091
32092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32093   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32094
32095   arg1 = (Dali::LongPressGesture *)jarg1;
32096   {
32097     try {
32098       delete arg1;
32099     } catch (std::out_of_range& e) {
32100       {
32101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32102       };
32103     } catch (std::exception& e) {
32104       {
32105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32106       };
32107     } catch (Dali::DaliException e) {
32108       {
32109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32110       };
32111     } catch (...) {
32112       {
32113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32114       };
32115     }
32116   }
32117
32118 }
32119
32120
32121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32122   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32123   unsigned int arg2 ;
32124
32125   arg1 = (Dali::LongPressGesture *)jarg1;
32126   arg2 = (unsigned int)jarg2;
32127   if (arg1) (arg1)->numberOfTouches = arg2;
32128 }
32129
32130
32131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32132   unsigned int jresult ;
32133   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32134   unsigned int result;
32135
32136   arg1 = (Dali::LongPressGesture *)jarg1;
32137   result = (unsigned int) ((arg1)->numberOfTouches);
32138   jresult = result;
32139   return jresult;
32140 }
32141
32142
32143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32144   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32145   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32146
32147   arg1 = (Dali::LongPressGesture *)jarg1;
32148   arg2 = (Dali::Vector2 *)jarg2;
32149   if (arg1) (arg1)->screenPoint = *arg2;
32150 }
32151
32152
32153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32154   void * jresult ;
32155   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32156   Dali::Vector2 *result = 0 ;
32157
32158   arg1 = (Dali::LongPressGesture *)jarg1;
32159   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32160   jresult = (void *)result;
32161   return jresult;
32162 }
32163
32164
32165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32166   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32167   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32168
32169   arg1 = (Dali::LongPressGesture *)jarg1;
32170   arg2 = (Dali::Vector2 *)jarg2;
32171   if (arg1) (arg1)->localPoint = *arg2;
32172 }
32173
32174
32175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32176   void * jresult ;
32177   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32178   Dali::Vector2 *result = 0 ;
32179
32180   arg1 = (Dali::LongPressGesture *)jarg1;
32181   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32182   jresult = (void *)result;
32183   return jresult;
32184 }
32185
32186
32187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32188   void * jresult ;
32189   Dali::WheelEvent *result = 0 ;
32190
32191   {
32192     try {
32193       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32194     } catch (std::out_of_range& e) {
32195       {
32196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32197       };
32198     } catch (std::exception& e) {
32199       {
32200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32201       };
32202     } catch (Dali::DaliException e) {
32203       {
32204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32205       };
32206     } catch (...) {
32207       {
32208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32209       };
32210     }
32211   }
32212
32213   jresult = (void *)result;
32214   return jresult;
32215 }
32216
32217
32218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32219   void * jresult ;
32220   Dali::WheelEvent::Type arg1 ;
32221   int arg2 ;
32222   unsigned int arg3 ;
32223   Dali::Vector2 arg4 ;
32224   int arg5 ;
32225   unsigned int arg6 ;
32226   Dali::Vector2 *argp4 ;
32227   Dali::WheelEvent *result = 0 ;
32228
32229   arg1 = (Dali::WheelEvent::Type)jarg1;
32230   arg2 = (int)jarg2;
32231   arg3 = (unsigned int)jarg3;
32232   argp4 = (Dali::Vector2 *)jarg4;
32233   if (!argp4) {
32234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32235     return 0;
32236   }
32237   arg4 = *argp4;
32238   arg5 = (int)jarg5;
32239   arg6 = (unsigned int)jarg6;
32240   {
32241     try {
32242       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32243     } catch (std::out_of_range& e) {
32244       {
32245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32246       };
32247     } catch (std::exception& e) {
32248       {
32249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32250       };
32251     } catch (Dali::DaliException e) {
32252       {
32253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32254       };
32255     } catch (...) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32258       };
32259     }
32260   }
32261
32262   jresult = (void *)result;
32263   return jresult;
32264 }
32265
32266
32267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32268   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32269
32270   arg1 = (Dali::WheelEvent *)jarg1;
32271   {
32272     try {
32273       delete arg1;
32274     } catch (std::out_of_range& e) {
32275       {
32276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32277       };
32278     } catch (std::exception& e) {
32279       {
32280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32281       };
32282     } catch (Dali::DaliException e) {
32283       {
32284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32285       };
32286     } catch (...) {
32287       {
32288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32289       };
32290     }
32291   }
32292
32293 }
32294
32295
32296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32297   unsigned int jresult ;
32298   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32299   bool result;
32300
32301   arg1 = (Dali::WheelEvent *)jarg1;
32302   {
32303     try {
32304       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32305     } catch (std::out_of_range& e) {
32306       {
32307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32308       };
32309     } catch (std::exception& e) {
32310       {
32311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32312       };
32313     } catch (Dali::DaliException e) {
32314       {
32315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32316       };
32317     } catch (...) {
32318       {
32319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32320       };
32321     }
32322   }
32323
32324   jresult = result;
32325   return jresult;
32326 }
32327
32328
32329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32330   unsigned int jresult ;
32331   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32332   bool result;
32333
32334   arg1 = (Dali::WheelEvent *)jarg1;
32335   {
32336     try {
32337       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32338     } catch (std::out_of_range& e) {
32339       {
32340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32341       };
32342     } catch (std::exception& e) {
32343       {
32344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32345       };
32346     } catch (Dali::DaliException e) {
32347       {
32348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32349       };
32350     } catch (...) {
32351       {
32352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32353       };
32354     }
32355   }
32356
32357   jresult = result;
32358   return jresult;
32359 }
32360
32361
32362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32363   unsigned int jresult ;
32364   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32365   bool result;
32366
32367   arg1 = (Dali::WheelEvent *)jarg1;
32368   {
32369     try {
32370       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32371     } catch (std::out_of_range& e) {
32372       {
32373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32374       };
32375     } catch (std::exception& e) {
32376       {
32377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32378       };
32379     } catch (Dali::DaliException e) {
32380       {
32381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32382       };
32383     } catch (...) {
32384       {
32385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32386       };
32387     }
32388   }
32389
32390   jresult = result;
32391   return jresult;
32392 }
32393
32394
32395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32396   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32397   Dali::WheelEvent::Type arg2 ;
32398
32399   arg1 = (Dali::WheelEvent *)jarg1;
32400   arg2 = (Dali::WheelEvent::Type)jarg2;
32401   if (arg1) (arg1)->type = arg2;
32402 }
32403
32404
32405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32406   int jresult ;
32407   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32408   Dali::WheelEvent::Type result;
32409
32410   arg1 = (Dali::WheelEvent *)jarg1;
32411   result = (Dali::WheelEvent::Type) ((arg1)->type);
32412   jresult = (int)result;
32413   return jresult;
32414 }
32415
32416
32417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32418   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32419   int arg2 ;
32420
32421   arg1 = (Dali::WheelEvent *)jarg1;
32422   arg2 = (int)jarg2;
32423   if (arg1) (arg1)->direction = arg2;
32424 }
32425
32426
32427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32428   int jresult ;
32429   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32430   int result;
32431
32432   arg1 = (Dali::WheelEvent *)jarg1;
32433   result = (int) ((arg1)->direction);
32434   jresult = result;
32435   return jresult;
32436 }
32437
32438
32439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32440   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32441   unsigned int arg2 ;
32442
32443   arg1 = (Dali::WheelEvent *)jarg1;
32444   arg2 = (unsigned int)jarg2;
32445   if (arg1) (arg1)->modifiers = arg2;
32446 }
32447
32448
32449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32450   unsigned int jresult ;
32451   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32452   unsigned int result;
32453
32454   arg1 = (Dali::WheelEvent *)jarg1;
32455   result = (unsigned int) ((arg1)->modifiers);
32456   jresult = result;
32457   return jresult;
32458 }
32459
32460
32461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32462   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32463   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32464
32465   arg1 = (Dali::WheelEvent *)jarg1;
32466   arg2 = (Dali::Vector2 *)jarg2;
32467   if (arg1) (arg1)->point = *arg2;
32468 }
32469
32470
32471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32472   void * jresult ;
32473   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32474   Dali::Vector2 *result = 0 ;
32475
32476   arg1 = (Dali::WheelEvent *)jarg1;
32477   result = (Dali::Vector2 *)& ((arg1)->point);
32478   jresult = (void *)result;
32479   return jresult;
32480 }
32481
32482
32483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32484   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32485   int arg2 ;
32486
32487   arg1 = (Dali::WheelEvent *)jarg1;
32488   arg2 = (int)jarg2;
32489   if (arg1) (arg1)->z = arg2;
32490 }
32491
32492
32493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32494   int jresult ;
32495   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32496   int result;
32497
32498   arg1 = (Dali::WheelEvent *)jarg1;
32499   result = (int) ((arg1)->z);
32500   jresult = result;
32501   return jresult;
32502 }
32503
32504
32505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32506   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32507   unsigned int arg2 ;
32508
32509   arg1 = (Dali::WheelEvent *)jarg1;
32510   arg2 = (unsigned int)jarg2;
32511   if (arg1) (arg1)->timeStamp = arg2;
32512 }
32513
32514
32515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32516   unsigned int jresult ;
32517   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32518   unsigned int result;
32519
32520   arg1 = (Dali::WheelEvent *)jarg1;
32521   result = (unsigned int) ((arg1)->timeStamp);
32522   jresult = result;
32523   return jresult;
32524 }
32525
32526 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32527   char * jresult ;
32528   Dali::KeyEvent *arg1 = 0 ;
32529   std::string result;
32530
32531   arg1 = (Dali::KeyEvent *)jarg1;
32532   if (!arg1) {
32533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32534     return 0;
32535   }
32536   {
32537     try {
32538       result = arg1->GetDeviceName();
32539     } catch (std::out_of_range& e) {
32540       {
32541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32542       };
32543     } catch (std::exception& e) {
32544       {
32545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32546       };
32547     } catch (Dali::DaliException e) {
32548       {
32549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32550       };
32551     } catch (...) {
32552       {
32553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32554       };
32555     }
32556   }
32557
32558   jresult = SWIG_csharp_string_callback((&result)->c_str());
32559   return jresult;
32560 }
32561
32562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32563   int jresult ;
32564   Dali::KeyEvent *arg1 = 0 ;
32565   Dali::Device::Class::Type result;
32566
32567   arg1 = (Dali::KeyEvent *)jarg1;
32568   if (!arg1) {
32569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32570     return 0;
32571   }
32572   {
32573     try {
32574       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32575     } catch (std::out_of_range& e) {
32576       {
32577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32578       };
32579     } catch (std::exception& e) {
32580       {
32581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32582       };
32583     } catch (Dali::DaliException e) {
32584       {
32585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32586       };
32587     } catch (...) {
32588       {
32589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32590       };
32591     }
32592   }
32593
32594   jresult = (int)result;
32595   return jresult;
32596 }
32597
32598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32599   int jresult ;
32600   Dali::KeyEvent *arg1 = 0 ;
32601   Dali::Device::Subclass::Type result;
32602
32603   arg1 = (Dali::KeyEvent *)jarg1;
32604   if (!arg1) {
32605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32606     return 0;
32607   }
32608   {
32609     try {
32610       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32611     } catch (std::out_of_range& e) {
32612       {
32613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32614       };
32615     } catch (std::exception& e) {
32616       {
32617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32618       };
32619     } catch (Dali::DaliException e) {
32620       {
32621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32622       };
32623     } catch (...) {
32624       {
32625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32626       };
32627     }
32628   }
32629
32630   jresult = (int)result;
32631   return jresult;
32632 }
32633
32634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32635   Dali::Actor arg1 ;
32636   Dali::Actor *argp1 ;
32637
32638   argp1 = (Dali::Actor *)jarg1;
32639   if (!argp1) {
32640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32641     return ;
32642   }
32643   arg1 = *argp1;
32644   {
32645     try {
32646       arg1.Raise();
32647     } catch (std::out_of_range& e) {
32648       {
32649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32650       };
32651     } catch (std::exception& e) {
32652       {
32653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32654       };
32655     } catch (Dali::DaliException e) {
32656       {
32657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32658       };
32659     } catch (...) {
32660       {
32661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32662       };
32663     }
32664   }
32665
32666 }
32667
32668
32669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32670   Dali::Actor arg1 ;
32671   Dali::Actor *argp1 ;
32672
32673   argp1 = (Dali::Actor *)jarg1;
32674   if (!argp1) {
32675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32676     return ;
32677   }
32678   arg1 = *argp1;
32679   {
32680     try {
32681       arg1.Lower();
32682     } catch (std::out_of_range& e) {
32683       {
32684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32685       };
32686     } catch (std::exception& e) {
32687       {
32688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32689       };
32690     } catch (Dali::DaliException e) {
32691       {
32692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32693       };
32694     } catch (...) {
32695       {
32696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32697       };
32698     }
32699   }
32700
32701 }
32702
32703
32704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32705   Dali::Actor arg1 ;
32706   Dali::Actor *argp1 ;
32707
32708   argp1 = (Dali::Actor *)jarg1;
32709   if (!argp1) {
32710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32711     return ;
32712   }
32713   arg1 = *argp1;
32714   {
32715     try {
32716       arg1.RaiseToTop();
32717     } catch (std::out_of_range& e) {
32718       {
32719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32720       };
32721     } catch (std::exception& e) {
32722       {
32723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32724       };
32725     } catch (Dali::DaliException e) {
32726       {
32727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32728       };
32729     } catch (...) {
32730       {
32731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32732       };
32733     }
32734   }
32735
32736 }
32737
32738
32739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32740   Dali::Actor arg1 ;
32741   Dali::Actor *argp1 ;
32742
32743   argp1 = (Dali::Actor *)jarg1;
32744   if (!argp1) {
32745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32746     return ;
32747   }
32748   arg1 = *argp1;
32749   {
32750     try {
32751       arg1.LowerToBottom();
32752     } catch (std::out_of_range& e) {
32753       {
32754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32755       };
32756     } catch (std::exception& e) {
32757       {
32758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32759       };
32760     } catch (Dali::DaliException e) {
32761       {
32762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32763       };
32764     } catch (...) {
32765       {
32766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32767       };
32768     }
32769   }
32770
32771 }
32772
32773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32774   Dali::Actor arg1 ;
32775   Dali::Actor arg2 ;
32776   Dali::Actor *argp1 ;
32777   Dali::Actor *argp2 ;
32778
32779   argp1 = (Dali::Actor *)jarg1;
32780   if (!argp1) {
32781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32782     return ;
32783   }
32784   arg1 = *argp1;
32785   argp2 = (Dali::Actor *)jarg2;
32786   if (!argp2) {
32787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32788     return ;
32789   }
32790   arg2 = *argp2;
32791   {
32792     try {
32793       arg1.RaiseAbove(arg2);
32794     } catch (std::out_of_range& e) {
32795       {
32796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32797       };
32798     } catch (std::exception& e) {
32799       {
32800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32801       };
32802     } catch (Dali::DaliException e) {
32803       {
32804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32805       };
32806     } catch (...) {
32807       {
32808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32809       };
32810     }
32811   }
32812
32813 }
32814
32815
32816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32817   Dali::Actor arg1 ;
32818   Dali::Actor arg2 ;
32819   Dali::Actor *argp1 ;
32820   Dali::Actor *argp2 ;
32821
32822   argp1 = (Dali::Actor *)jarg1;
32823   if (!argp1) {
32824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32825     return ;
32826   }
32827   arg1 = *argp1;
32828   argp2 = (Dali::Actor *)jarg2;
32829   if (!argp2) {
32830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32831     return ;
32832   }
32833   arg2 = *argp2;
32834   {
32835     try {
32836       arg1.LowerBelow(arg2);
32837     } catch (std::out_of_range& e) {
32838       {
32839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32840       };
32841     } catch (std::exception& e) {
32842       {
32843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32844       };
32845     } catch (Dali::DaliException e) {
32846       {
32847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32848       };
32849     } catch (...) {
32850       {
32851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32852       };
32853     }
32854   }
32855
32856 }
32857
32858
32859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32860   void * jresult ;
32861   Dali::Actor arg1 ;
32862   Dali::Actor *argp1 ;
32863   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32864
32865   argp1 = (Dali::Actor *)jarg1;
32866   if (!argp1) {
32867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32868     return 0;
32869   }
32870   arg1 = *argp1;
32871   {
32872     try {
32873       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32874     } catch (std::out_of_range& e) {
32875       {
32876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32877       };
32878     } catch (std::exception& e) {
32879       {
32880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32881       };
32882     } catch (Dali::DaliException e) {
32883       {
32884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32885       };
32886     } catch (...) {
32887       {
32888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32889       };
32890     }
32891   }
32892
32893   jresult = (void *)result;
32894   return jresult;
32895 }
32896
32897
32898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32899   void * jresult ;
32900   Dali::Actor *arg1 ;
32901   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32902
32903   arg1 = (Dali::Actor *)jarg1;
32904   {
32905     try {
32906       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32907     } catch (std::out_of_range& e) {
32908       {
32909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32910       };
32911     } catch (std::exception& e) {
32912       {
32913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32914       };
32915     } catch (Dali::DaliException e) {
32916       {
32917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32918       };
32919     } catch (...) {
32920       {
32921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32922       };
32923     }
32924   }
32925
32926   jresult = (void *)result;
32927   return jresult;
32928 }
32929
32930
32931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32932   int jresult ;
32933   int result;
32934
32935   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32936   jresult = (int)result;
32937   return jresult;
32938 }
32939
32940
32941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32942   int jresult ;
32943   int result;
32944
32945   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32946   jresult = (int)result;
32947   return jresult;
32948 }
32949
32950
32951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32952   int jresult ;
32953   int result;
32954
32955   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32956   jresult = (int)result;
32957   return jresult;
32958 }
32959
32960
32961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32962   int jresult ;
32963   int result;
32964
32965   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32966   jresult = (int)result;
32967   return jresult;
32968 }
32969
32970
32971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32972   int jresult ;
32973   int result;
32974
32975   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32976   jresult = (int)result;
32977   return jresult;
32978 }
32979
32980
32981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32982   int jresult ;
32983   int result;
32984
32985   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32986   jresult = (int)result;
32987   return jresult;
32988 }
32989
32990
32991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32992   int jresult ;
32993   int result;
32994
32995   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32996   jresult = (int)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::SIZE;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::POSITION;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::POSITION_X;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::POSITION_Y;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::POSITION_Z;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::WORLD_POSITION;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::ORIENTATION;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33152   int jresult ;
33153   int result;
33154
33155   result = (int)Dali::Actor::Property::SCALE;
33156   jresult = (int)result;
33157   return jresult;
33158 }
33159
33160
33161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33162   int jresult ;
33163   int result;
33164
33165   result = (int)Dali::Actor::Property::SCALE_X;
33166   jresult = (int)result;
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33172   int jresult ;
33173   int result;
33174
33175   result = (int)Dali::Actor::Property::SCALE_Y;
33176   jresult = (int)result;
33177   return jresult;
33178 }
33179
33180
33181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33182   int jresult ;
33183   int result;
33184
33185   result = (int)Dali::Actor::Property::SCALE_Z;
33186   jresult = (int)result;
33187   return jresult;
33188 }
33189
33190
33191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33192   int jresult ;
33193   int result;
33194
33195   result = (int)Dali::Actor::Property::WORLD_SCALE;
33196   jresult = (int)result;
33197   return jresult;
33198 }
33199
33200
33201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33202   int jresult ;
33203   int result;
33204
33205   result = (int)Dali::Actor::Property::VISIBLE;
33206   jresult = (int)result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33212   int jresult ;
33213   int result;
33214
33215   result = (int)Dali::Actor::Property::COLOR;
33216   jresult = (int)result;
33217   return jresult;
33218 }
33219
33220
33221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33222   int jresult ;
33223   int result;
33224
33225   result = (int)Dali::Actor::Property::COLOR_RED;
33226   jresult = (int)result;
33227   return jresult;
33228 }
33229
33230
33231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33232   int jresult ;
33233   int result;
33234
33235   result = (int)Dali::Actor::Property::COLOR_GREEN;
33236   jresult = (int)result;
33237   return jresult;
33238 }
33239
33240
33241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33242   int jresult ;
33243   int result;
33244
33245   result = (int)Dali::Actor::Property::COLOR_BLUE;
33246   jresult = (int)result;
33247   return jresult;
33248 }
33249
33250
33251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33252   int jresult ;
33253   int result;
33254
33255   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33256   jresult = (int)result;
33257   return jresult;
33258 }
33259
33260
33261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33262   int jresult ;
33263   int result;
33264
33265   result = (int)Dali::Actor::Property::WORLD_COLOR;
33266   jresult = (int)result;
33267   return jresult;
33268 }
33269
33270
33271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33272   int jresult ;
33273   int result;
33274
33275   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33276   jresult = (int)result;
33277   return jresult;
33278 }
33279
33280
33281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33282   int jresult ;
33283   int result;
33284
33285   result = (int)Dali::Actor::Property::NAME;
33286   jresult = (int)result;
33287   return jresult;
33288 }
33289
33290
33291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33292   int jresult ;
33293   int result;
33294
33295   result = (int)Dali::Actor::Property::SENSITIVE;
33296   jresult = (int)result;
33297   return jresult;
33298 }
33299
33300
33301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33302   int jresult ;
33303   int result;
33304
33305   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33306   jresult = (int)result;
33307   return jresult;
33308 }
33309
33310
33311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33312   int jresult ;
33313   int result;
33314
33315   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33316   jresult = (int)result;
33317   return jresult;
33318 }
33319
33320
33321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33322   int jresult ;
33323   int result;
33324
33325   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33326   jresult = (int)result;
33327   return jresult;
33328 }
33329
33330
33331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33332   int jresult ;
33333   int result;
33334
33335   result = (int)Dali::Actor::Property::COLOR_MODE;
33336   jresult = (int)result;
33337   return jresult;
33338 }
33339
33340
33341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33342   int jresult ;
33343   int result;
33344
33345   result = (int)Dali::Actor::Property::DRAW_MODE;
33346   jresult = (int)result;
33347   return jresult;
33348 }
33349
33350
33351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33352   int jresult ;
33353   int result;
33354
33355   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33356   jresult = (int)result;
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33362   int jresult ;
33363   int result;
33364
33365   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33366   jresult = (int)result;
33367   return jresult;
33368 }
33369
33370
33371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33372   int jresult ;
33373   int result;
33374
33375   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33376   jresult = (int)result;
33377   return jresult;
33378 }
33379
33380
33381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33382   int jresult ;
33383   int result;
33384
33385   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33386   jresult = (int)result;
33387   return jresult;
33388 }
33389
33390
33391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33392   int jresult ;
33393   int result;
33394
33395   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33396   jresult = (int)result;
33397   return jresult;
33398 }
33399
33400
33401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33402   int jresult ;
33403   int result;
33404
33405   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33406   jresult = (int)result;
33407   return jresult;
33408 }
33409
33410
33411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33412   int jresult ;
33413   int result;
33414
33415   result = (int)Dali::Actor::Property::PADDING;
33416   jresult = (int)result;
33417   return jresult;
33418 }
33419
33420
33421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33422   int jresult ;
33423   int result;
33424
33425   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33426   jresult = (int)result;
33427   return jresult;
33428 }
33429
33430
33431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33432   int jresult ;
33433   int result;
33434
33435   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33436   jresult = (int)result;
33437   return jresult;
33438 }
33439
33440
33441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33442   int jresult ;
33443   int result;
33444
33445   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33446   jresult = (int)result;
33447   return jresult;
33448 }
33449
33450
33451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33452   int jresult ;
33453   int result;
33454
33455   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33456   jresult = (int)result;
33457   return jresult;
33458 }
33459
33460
33461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33462   void * jresult ;
33463   Dali::Actor::Property *result = 0 ;
33464
33465   {
33466     try {
33467       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33468     } catch (std::out_of_range& e) {
33469       {
33470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33471       };
33472     } catch (std::exception& e) {
33473       {
33474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (Dali::DaliException e) {
33477       {
33478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33479       };
33480     } catch (...) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33483       };
33484     }
33485   }
33486
33487   jresult = (void *)result;
33488   return jresult;
33489 }
33490
33491
33492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33493   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33494
33495   arg1 = (Dali::Actor::Property *)jarg1;
33496   {
33497     try {
33498       delete arg1;
33499     } catch (std::out_of_range& e) {
33500       {
33501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33502       };
33503     } catch (std::exception& e) {
33504       {
33505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33506       };
33507     } catch (Dali::DaliException e) {
33508       {
33509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33510       };
33511     } catch (...) {
33512       {
33513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33514       };
33515     }
33516   }
33517
33518 }
33519
33520
33521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33522   void * jresult ;
33523   Dali::Actor *result = 0 ;
33524
33525   {
33526     try {
33527       result = (Dali::Actor *)new Dali::Actor();
33528     } catch (std::out_of_range& e) {
33529       {
33530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33531       };
33532     } catch (std::exception& e) {
33533       {
33534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33535       };
33536     } catch (Dali::DaliException e) {
33537       {
33538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33539       };
33540     } catch (...) {
33541       {
33542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33543       };
33544     }
33545   }
33546
33547   jresult = (void *)result;
33548   return jresult;
33549 }
33550
33551
33552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33553   void * jresult ;
33554   Dali::Actor result;
33555
33556   {
33557     try {
33558       result = Dali::Actor::New();
33559     } catch (std::out_of_range& e) {
33560       {
33561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33562       };
33563     } catch (std::exception& e) {
33564       {
33565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33566       };
33567     } catch (Dali::DaliException e) {
33568       {
33569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33570       };
33571     } catch (...) {
33572       {
33573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33574       };
33575     }
33576   }
33577
33578   jresult = new Dali::Actor((const Dali::Actor &)result);
33579   return jresult;
33580 }
33581
33582
33583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33584   void * jresult ;
33585   Dali::BaseHandle arg1 ;
33586   Dali::BaseHandle *argp1 ;
33587   Dali::Actor result;
33588
33589   argp1 = (Dali::BaseHandle *)jarg1;
33590   if (!argp1) {
33591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33592     return 0;
33593   }
33594   arg1 = *argp1;
33595   {
33596     try {
33597       result = Dali::Actor::DownCast(arg1);
33598     } catch (std::out_of_range& e) {
33599       {
33600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33601       };
33602     } catch (std::exception& e) {
33603       {
33604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33605       };
33606     } catch (Dali::DaliException e) {
33607       {
33608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33609       };
33610     } catch (...) {
33611       {
33612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33613       };
33614     }
33615   }
33616
33617   jresult = new Dali::Actor((const Dali::Actor &)result);
33618   return jresult;
33619 }
33620
33621
33622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33623   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33624
33625   arg1 = (Dali::Actor *)jarg1;
33626   {
33627     try {
33628       delete arg1;
33629     } catch (std::out_of_range& e) {
33630       {
33631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33632       };
33633     } catch (std::exception& e) {
33634       {
33635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33636       };
33637     } catch (Dali::DaliException e) {
33638       {
33639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33640       };
33641     } catch (...) {
33642       {
33643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33644       };
33645     }
33646   }
33647
33648 }
33649
33650
33651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33652   void * jresult ;
33653   Dali::Actor *arg1 = 0 ;
33654   Dali::Actor *result = 0 ;
33655
33656   arg1 = (Dali::Actor *)jarg1;
33657   if (!arg1) {
33658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33659     return 0;
33660   }
33661   {
33662     try {
33663       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33664     } catch (std::out_of_range& e) {
33665       {
33666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33667       };
33668     } catch (std::exception& e) {
33669       {
33670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33671       };
33672     } catch (Dali::DaliException e) {
33673       {
33674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33675       };
33676     } catch (...) {
33677       {
33678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33679       };
33680     }
33681   }
33682
33683   jresult = (void *)result;
33684   return jresult;
33685 }
33686
33687
33688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33689   void * jresult ;
33690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33691   Dali::Actor *arg2 = 0 ;
33692   Dali::Actor *result = 0 ;
33693
33694   arg1 = (Dali::Actor *)jarg1;
33695   arg2 = (Dali::Actor *)jarg2;
33696   if (!arg2) {
33697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33698     return 0;
33699   }
33700   {
33701     try {
33702       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33703     } catch (std::out_of_range& e) {
33704       {
33705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33706       };
33707     } catch (std::exception& e) {
33708       {
33709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33710       };
33711     } catch (Dali::DaliException e) {
33712       {
33713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33714       };
33715     } catch (...) {
33716       {
33717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33718       };
33719     }
33720   }
33721
33722   jresult = (void *)result;
33723   return jresult;
33724 }
33725
33726
33727 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33728   char * jresult ;
33729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33730   std::string *result = 0 ;
33731
33732   arg1 = (Dali::Actor *)jarg1;
33733   {
33734     try {
33735       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33736     } catch (std::out_of_range& e) {
33737       {
33738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33739       };
33740     } catch (std::exception& e) {
33741       {
33742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33743       };
33744     } catch (Dali::DaliException e) {
33745       {
33746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33747       };
33748     } catch (...) {
33749       {
33750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33751       };
33752     }
33753   }
33754
33755   jresult = SWIG_csharp_string_callback(result->c_str());
33756   return jresult;
33757 }
33758
33759
33760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33762   std::string *arg2 = 0 ;
33763
33764   arg1 = (Dali::Actor *)jarg1;
33765   if (!jarg2) {
33766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33767     return ;
33768   }
33769   std::string arg2_str(jarg2);
33770   arg2 = &arg2_str;
33771   {
33772     try {
33773       (arg1)->SetName((std::string const &)*arg2);
33774     } catch (std::out_of_range& e) {
33775       {
33776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33777       };
33778     } catch (std::exception& e) {
33779       {
33780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33781       };
33782     } catch (Dali::DaliException e) {
33783       {
33784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33785       };
33786     } catch (...) {
33787       {
33788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33789       };
33790     }
33791   }
33792
33793
33794   //argout typemap for const std::string&
33795
33796 }
33797
33798
33799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33800   unsigned int jresult ;
33801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33802   unsigned int result;
33803
33804   arg1 = (Dali::Actor *)jarg1;
33805   {
33806     try {
33807       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33808     } catch (std::out_of_range& e) {
33809       {
33810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33811       };
33812     } catch (std::exception& e) {
33813       {
33814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33815       };
33816     } catch (Dali::DaliException e) {
33817       {
33818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33819       };
33820     } catch (...) {
33821       {
33822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33823       };
33824     }
33825   }
33826
33827   jresult = result;
33828   return jresult;
33829 }
33830
33831
33832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33833   unsigned int jresult ;
33834   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33835   bool result;
33836
33837   arg1 = (Dali::Actor *)jarg1;
33838   {
33839     try {
33840       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33841     } catch (std::out_of_range& e) {
33842       {
33843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33844       };
33845     } catch (std::exception& e) {
33846       {
33847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33848       };
33849     } catch (Dali::DaliException e) {
33850       {
33851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33852       };
33853     } catch (...) {
33854       {
33855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33856       };
33857     }
33858   }
33859
33860   jresult = result;
33861   return jresult;
33862 }
33863
33864
33865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33866   unsigned int jresult ;
33867   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33868   bool result;
33869
33870   arg1 = (Dali::Actor *)jarg1;
33871   {
33872     try {
33873       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33874     } catch (std::out_of_range& e) {
33875       {
33876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33877       };
33878     } catch (std::exception& e) {
33879       {
33880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33881       };
33882     } catch (Dali::DaliException e) {
33883       {
33884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33885       };
33886     } catch (...) {
33887       {
33888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33889       };
33890     }
33891   }
33892
33893   jresult = result;
33894   return jresult;
33895 }
33896
33897
33898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33899   unsigned int jresult ;
33900   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33901   bool result;
33902
33903   arg1 = (Dali::Actor *)jarg1;
33904   {
33905     try {
33906       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33907     } catch (std::out_of_range& e) {
33908       {
33909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33910       };
33911     } catch (std::exception& e) {
33912       {
33913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33914       };
33915     } catch (Dali::DaliException e) {
33916       {
33917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33918       };
33919     } catch (...) {
33920       {
33921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33922       };
33923     }
33924   }
33925
33926   jresult = result;
33927   return jresult;
33928 }
33929
33930
33931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33932   void * jresult ;
33933   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33934   Dali::Layer result;
33935
33936   arg1 = (Dali::Actor *)jarg1;
33937   {
33938     try {
33939       result = (arg1)->GetLayer();
33940     } catch (std::out_of_range& e) {
33941       {
33942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33943       };
33944     } catch (std::exception& e) {
33945       {
33946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33947       };
33948     } catch (Dali::DaliException e) {
33949       {
33950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33951       };
33952     } catch (...) {
33953       {
33954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33955       };
33956     }
33957   }
33958
33959   jresult = new Dali::Layer((const Dali::Layer &)result);
33960   return jresult;
33961 }
33962
33963
33964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33965   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33966   Dali::Actor arg2 ;
33967   Dali::Actor *argp2 ;
33968
33969   arg1 = (Dali::Actor *)jarg1;
33970   argp2 = (Dali::Actor *)jarg2;
33971   if (!argp2) {
33972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33973     return ;
33974   }
33975   arg2 = *argp2;
33976   {
33977     try {
33978       (arg1)->Add(arg2);
33979     } catch (std::out_of_range& e) {
33980       {
33981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33982       };
33983     } catch (std::exception& e) {
33984       {
33985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33986       };
33987     } catch (Dali::DaliException e) {
33988       {
33989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33990       };
33991     } catch (...) {
33992       {
33993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33994       };
33995     }
33996   }
33997
33998 }
33999
34000
34001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34002   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34003   Dali::Actor arg2 ;
34004   Dali::Actor *argp2 ;
34005
34006   arg1 = (Dali::Actor *)jarg1;
34007   argp2 = (Dali::Actor *)jarg2;
34008   if (!argp2) {
34009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34010     return ;
34011   }
34012   arg2 = *argp2;
34013   {
34014     try {
34015       (arg1)->Remove(arg2);
34016     } catch (std::out_of_range& e) {
34017       {
34018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34019       };
34020     } catch (std::exception& e) {
34021       {
34022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34023       };
34024     } catch (Dali::DaliException e) {
34025       {
34026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34027       };
34028     } catch (...) {
34029       {
34030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34031       };
34032     }
34033   }
34034
34035 }
34036
34037
34038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34039   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34040
34041   arg1 = (Dali::Actor *)jarg1;
34042   {
34043     try {
34044       (arg1)->Unparent();
34045     } catch (std::out_of_range& e) {
34046       {
34047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34048       };
34049     } catch (std::exception& e) {
34050       {
34051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34052       };
34053     } catch (Dali::DaliException e) {
34054       {
34055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34056       };
34057     } catch (...) {
34058       {
34059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34060       };
34061     }
34062   }
34063
34064 }
34065
34066
34067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34068   unsigned int jresult ;
34069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34070   unsigned int result;
34071
34072   arg1 = (Dali::Actor *)jarg1;
34073   {
34074     try {
34075       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34076     } catch (std::out_of_range& e) {
34077       {
34078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34079       };
34080     } catch (std::exception& e) {
34081       {
34082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34083       };
34084     } catch (Dali::DaliException e) {
34085       {
34086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34087       };
34088     } catch (...) {
34089       {
34090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34091       };
34092     }
34093   }
34094
34095   jresult = result;
34096   return jresult;
34097 }
34098
34099
34100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34101   void * jresult ;
34102   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34103   unsigned int arg2 ;
34104   Dali::Actor result;
34105
34106   arg1 = (Dali::Actor *)jarg1;
34107   arg2 = (unsigned int)jarg2;
34108   {
34109     try {
34110       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34111     } catch (std::out_of_range& e) {
34112       {
34113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34114       };
34115     } catch (std::exception& e) {
34116       {
34117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34118       };
34119     } catch (Dali::DaliException e) {
34120       {
34121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34122       };
34123     } catch (...) {
34124       {
34125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34126       };
34127     }
34128   }
34129
34130   jresult = new Dali::Actor((const Dali::Actor &)result);
34131   return jresult;
34132 }
34133
34134
34135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34136   void * jresult ;
34137   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34138   std::string *arg2 = 0 ;
34139   Dali::Actor result;
34140
34141   arg1 = (Dali::Actor *)jarg1;
34142   if (!jarg2) {
34143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34144     return 0;
34145   }
34146   std::string arg2_str(jarg2);
34147   arg2 = &arg2_str;
34148   {
34149     try {
34150       result = (arg1)->FindChildByName((std::string const &)*arg2);
34151     } catch (std::out_of_range& e) {
34152       {
34153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34154       };
34155     } catch (std::exception& e) {
34156       {
34157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34158       };
34159     } catch (Dali::DaliException e) {
34160       {
34161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34162       };
34163     } catch (...) {
34164       {
34165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34166       };
34167     }
34168   }
34169
34170   jresult = new Dali::Actor((const Dali::Actor &)result);
34171
34172   //argout typemap for const std::string&
34173
34174   return jresult;
34175 }
34176
34177
34178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34179   void * jresult ;
34180   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34181   unsigned int arg2 ;
34182   Dali::Actor result;
34183
34184   arg1 = (Dali::Actor *)jarg1;
34185   arg2 = (unsigned int)jarg2;
34186   {
34187     try {
34188       result = (arg1)->FindChildById(arg2);
34189     } catch (std::out_of_range& e) {
34190       {
34191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34192       };
34193     } catch (std::exception& e) {
34194       {
34195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34196       };
34197     } catch (Dali::DaliException e) {
34198       {
34199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34200       };
34201     } catch (...) {
34202       {
34203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34204       };
34205     }
34206   }
34207
34208   jresult = new Dali::Actor((const Dali::Actor &)result);
34209   return jresult;
34210 }
34211
34212
34213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34214   void * jresult ;
34215   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34216   Dali::Actor result;
34217
34218   arg1 = (Dali::Actor *)jarg1;
34219   {
34220     try {
34221       result = ((Dali::Actor const *)arg1)->GetParent();
34222     } catch (std::out_of_range& e) {
34223       {
34224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34225       };
34226     } catch (std::exception& e) {
34227       {
34228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34229       };
34230     } catch (Dali::DaliException e) {
34231       {
34232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34233       };
34234     } catch (...) {
34235       {
34236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34237       };
34238     }
34239   }
34240
34241   jresult = new Dali::Actor((const Dali::Actor &)result);
34242   return jresult;
34243 }
34244
34245
34246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34247   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34248   Dali::Vector3 *arg2 = 0 ;
34249
34250   arg1 = (Dali::Actor *)jarg1;
34251   arg2 = (Dali::Vector3 *)jarg2;
34252   if (!arg2) {
34253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34254     return ;
34255   }
34256   {
34257     try {
34258       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34259     } catch (std::out_of_range& e) {
34260       {
34261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34262       };
34263     } catch (std::exception& e) {
34264       {
34265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34266       };
34267     } catch (Dali::DaliException e) {
34268       {
34269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34270       };
34271     } catch (...) {
34272       {
34273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34274       };
34275     }
34276   }
34277
34278 }
34279
34280
34281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34282   void * jresult ;
34283   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34284   Dali::Vector3 result;
34285
34286   arg1 = (Dali::Actor *)jarg1;
34287   {
34288     try {
34289       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34290     } catch (std::out_of_range& e) {
34291       {
34292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34293       };
34294     } catch (std::exception& e) {
34295       {
34296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34297       };
34298     } catch (Dali::DaliException e) {
34299       {
34300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34301       };
34302     } catch (...) {
34303       {
34304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34305       };
34306     }
34307   }
34308
34309   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34310   return jresult;
34311 }
34312
34313
34314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34315   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34316   Dali::Vector3 *arg2 = 0 ;
34317
34318   arg1 = (Dali::Actor *)jarg1;
34319   arg2 = (Dali::Vector3 *)jarg2;
34320   if (!arg2) {
34321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34322     return ;
34323   }
34324   {
34325     try {
34326       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34327     } catch (std::out_of_range& e) {
34328       {
34329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34330       };
34331     } catch (std::exception& e) {
34332       {
34333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34334       };
34335     } catch (Dali::DaliException e) {
34336       {
34337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34338       };
34339     } catch (...) {
34340       {
34341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34342       };
34343     }
34344   }
34345
34346 }
34347
34348
34349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34350   void * jresult ;
34351   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34352   Dali::Vector3 result;
34353
34354   arg1 = (Dali::Actor *)jarg1;
34355   {
34356     try {
34357       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34358     } catch (std::out_of_range& e) {
34359       {
34360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34361       };
34362     } catch (std::exception& e) {
34363       {
34364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34365       };
34366     } catch (Dali::DaliException e) {
34367       {
34368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34369       };
34370     } catch (...) {
34371       {
34372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34373       };
34374     }
34375   }
34376
34377   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34378   return jresult;
34379 }
34380
34381
34382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34383   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34384   float arg2 ;
34385   float arg3 ;
34386
34387   arg1 = (Dali::Actor *)jarg1;
34388   arg2 = (float)jarg2;
34389   arg3 = (float)jarg3;
34390   {
34391     try {
34392       (arg1)->SetSize(arg2,arg3);
34393     } catch (std::out_of_range& e) {
34394       {
34395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34396       };
34397     } catch (std::exception& e) {
34398       {
34399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34400       };
34401     } catch (Dali::DaliException e) {
34402       {
34403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34404       };
34405     } catch (...) {
34406       {
34407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34408       };
34409     }
34410   }
34411
34412 }
34413
34414
34415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34417   float arg2 ;
34418   float arg3 ;
34419   float arg4 ;
34420
34421   arg1 = (Dali::Actor *)jarg1;
34422   arg2 = (float)jarg2;
34423   arg3 = (float)jarg3;
34424   arg4 = (float)jarg4;
34425   {
34426     try {
34427       (arg1)->SetSize(arg2,arg3,arg4);
34428     } catch (std::out_of_range& e) {
34429       {
34430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34431       };
34432     } catch (std::exception& e) {
34433       {
34434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34435       };
34436     } catch (Dali::DaliException e) {
34437       {
34438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34439       };
34440     } catch (...) {
34441       {
34442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34443       };
34444     }
34445   }
34446
34447 }
34448
34449
34450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34451   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34452   Dali::Vector2 *arg2 = 0 ;
34453
34454   arg1 = (Dali::Actor *)jarg1;
34455   arg2 = (Dali::Vector2 *)jarg2;
34456   if (!arg2) {
34457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34458     return ;
34459   }
34460   {
34461     try {
34462       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34463     } catch (std::out_of_range& e) {
34464       {
34465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34466       };
34467     } catch (std::exception& e) {
34468       {
34469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34470       };
34471     } catch (Dali::DaliException e) {
34472       {
34473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34474       };
34475     } catch (...) {
34476       {
34477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34478       };
34479     }
34480   }
34481
34482 }
34483
34484
34485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34486   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34487   Dali::Vector3 *arg2 = 0 ;
34488
34489   arg1 = (Dali::Actor *)jarg1;
34490   arg2 = (Dali::Vector3 *)jarg2;
34491   if (!arg2) {
34492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34493     return ;
34494   }
34495   {
34496     try {
34497       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34498     } catch (std::out_of_range& e) {
34499       {
34500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34501       };
34502     } catch (std::exception& e) {
34503       {
34504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34505       };
34506     } catch (Dali::DaliException e) {
34507       {
34508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34509       };
34510     } catch (...) {
34511       {
34512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34513       };
34514     }
34515   }
34516
34517 }
34518
34519
34520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34521   void * jresult ;
34522   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34523   Dali::Vector3 result;
34524
34525   arg1 = (Dali::Actor *)jarg1;
34526   {
34527     try {
34528       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34529     } catch (std::out_of_range& e) {
34530       {
34531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34532       };
34533     } catch (std::exception& e) {
34534       {
34535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34536       };
34537     } catch (Dali::DaliException e) {
34538       {
34539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34540       };
34541     } catch (...) {
34542       {
34543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34544       };
34545     }
34546   }
34547
34548   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34549   return jresult;
34550 }
34551
34552
34553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34554   void * jresult ;
34555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34556   Dali::Vector3 result;
34557
34558   arg1 = (Dali::Actor *)jarg1;
34559   {
34560     try {
34561       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34562     } catch (std::out_of_range& e) {
34563       {
34564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34565       };
34566     } catch (std::exception& e) {
34567       {
34568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34569       };
34570     } catch (Dali::DaliException e) {
34571       {
34572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34573       };
34574     } catch (...) {
34575       {
34576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34577       };
34578     }
34579   }
34580
34581   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34582   return jresult;
34583 }
34584
34585
34586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34587   void * jresult ;
34588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34589   Dali::Vector3 result;
34590
34591   arg1 = (Dali::Actor *)jarg1;
34592   {
34593     try {
34594       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34595     } catch (std::out_of_range& e) {
34596       {
34597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34598       };
34599     } catch (std::exception& e) {
34600       {
34601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34602       };
34603     } catch (Dali::DaliException e) {
34604       {
34605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34606       };
34607     } catch (...) {
34608       {
34609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34610       };
34611     }
34612   }
34613
34614   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34615   return jresult;
34616 }
34617
34618
34619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34621   float arg2 ;
34622   float arg3 ;
34623
34624   arg1 = (Dali::Actor *)jarg1;
34625   arg2 = (float)jarg2;
34626   arg3 = (float)jarg3;
34627   {
34628     try {
34629       (arg1)->SetPosition(arg2,arg3);
34630     } catch (std::out_of_range& e) {
34631       {
34632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34633       };
34634     } catch (std::exception& e) {
34635       {
34636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34637       };
34638     } catch (Dali::DaliException e) {
34639       {
34640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34641       };
34642     } catch (...) {
34643       {
34644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34645       };
34646     }
34647   }
34648
34649 }
34650
34651
34652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34654   float arg2 ;
34655   float arg3 ;
34656   float arg4 ;
34657
34658   arg1 = (Dali::Actor *)jarg1;
34659   arg2 = (float)jarg2;
34660   arg3 = (float)jarg3;
34661   arg4 = (float)jarg4;
34662   {
34663     try {
34664       (arg1)->SetPosition(arg2,arg3,arg4);
34665     } catch (std::out_of_range& e) {
34666       {
34667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34668       };
34669     } catch (std::exception& e) {
34670       {
34671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34672       };
34673     } catch (Dali::DaliException e) {
34674       {
34675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34676       };
34677     } catch (...) {
34678       {
34679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34680       };
34681     }
34682   }
34683
34684 }
34685
34686
34687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34689   Dali::Vector3 *arg2 = 0 ;
34690
34691   arg1 = (Dali::Actor *)jarg1;
34692   arg2 = (Dali::Vector3 *)jarg2;
34693   if (!arg2) {
34694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34695     return ;
34696   }
34697   {
34698     try {
34699       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34700     } catch (std::out_of_range& e) {
34701       {
34702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34703       };
34704     } catch (std::exception& e) {
34705       {
34706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34707       };
34708     } catch (Dali::DaliException e) {
34709       {
34710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34711       };
34712     } catch (...) {
34713       {
34714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34715       };
34716     }
34717   }
34718
34719 }
34720
34721
34722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34724   float arg2 ;
34725
34726   arg1 = (Dali::Actor *)jarg1;
34727   arg2 = (float)jarg2;
34728   {
34729     try {
34730       (arg1)->SetX(arg2);
34731     } catch (std::out_of_range& e) {
34732       {
34733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34734       };
34735     } catch (std::exception& e) {
34736       {
34737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34738       };
34739     } catch (Dali::DaliException e) {
34740       {
34741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34742       };
34743     } catch (...) {
34744       {
34745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34746       };
34747     }
34748   }
34749
34750 }
34751
34752
34753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34754   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34755   float arg2 ;
34756
34757   arg1 = (Dali::Actor *)jarg1;
34758   arg2 = (float)jarg2;
34759   {
34760     try {
34761       (arg1)->SetY(arg2);
34762     } catch (std::out_of_range& e) {
34763       {
34764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34765       };
34766     } catch (std::exception& e) {
34767       {
34768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34769       };
34770     } catch (Dali::DaliException e) {
34771       {
34772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34773       };
34774     } catch (...) {
34775       {
34776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34777       };
34778     }
34779   }
34780
34781 }
34782
34783
34784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34786   float arg2 ;
34787
34788   arg1 = (Dali::Actor *)jarg1;
34789   arg2 = (float)jarg2;
34790   {
34791     try {
34792       (arg1)->SetZ(arg2);
34793     } catch (std::out_of_range& e) {
34794       {
34795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34796       };
34797     } catch (std::exception& e) {
34798       {
34799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34800       };
34801     } catch (Dali::DaliException e) {
34802       {
34803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34804       };
34805     } catch (...) {
34806       {
34807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34808       };
34809     }
34810   }
34811
34812 }
34813
34814
34815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34816   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34817   Dali::Vector3 *arg2 = 0 ;
34818
34819   arg1 = (Dali::Actor *)jarg1;
34820   arg2 = (Dali::Vector3 *)jarg2;
34821   if (!arg2) {
34822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34823     return ;
34824   }
34825   {
34826     try {
34827       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34828     } catch (std::out_of_range& e) {
34829       {
34830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34831       };
34832     } catch (std::exception& e) {
34833       {
34834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34835       };
34836     } catch (Dali::DaliException e) {
34837       {
34838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34839       };
34840     } catch (...) {
34841       {
34842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34843       };
34844     }
34845   }
34846
34847 }
34848
34849
34850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34851   void * jresult ;
34852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34853   Dali::Vector3 result;
34854
34855   arg1 = (Dali::Actor *)jarg1;
34856   {
34857     try {
34858       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34859     } catch (std::out_of_range& e) {
34860       {
34861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34862       };
34863     } catch (std::exception& e) {
34864       {
34865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34866       };
34867     } catch (Dali::DaliException e) {
34868       {
34869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34870       };
34871     } catch (...) {
34872       {
34873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34874       };
34875     }
34876   }
34877
34878   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34879   return jresult;
34880 }
34881
34882
34883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34884   void * jresult ;
34885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34886   Dali::Vector3 result;
34887
34888   arg1 = (Dali::Actor *)jarg1;
34889   {
34890     try {
34891       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34892     } catch (std::out_of_range& e) {
34893       {
34894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34895       };
34896     } catch (std::exception& e) {
34897       {
34898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34899       };
34900     } catch (Dali::DaliException e) {
34901       {
34902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34903       };
34904     } catch (...) {
34905       {
34906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34907       };
34908     }
34909   }
34910
34911   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34912   return jresult;
34913 }
34914
34915
34916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34918   bool arg2 ;
34919
34920   arg1 = (Dali::Actor *)jarg1;
34921   arg2 = jarg2 ? true : false;
34922   {
34923     try {
34924       (arg1)->SetInheritPosition(arg2);
34925     } catch (std::out_of_range& e) {
34926       {
34927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34928       };
34929     } catch (std::exception& e) {
34930       {
34931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34932       };
34933     } catch (Dali::DaliException e) {
34934       {
34935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34936       };
34937     } catch (...) {
34938       {
34939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34940       };
34941     }
34942   }
34943
34944 }
34945
34946
34947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34948   unsigned int jresult ;
34949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34950   bool result;
34951
34952   arg1 = (Dali::Actor *)jarg1;
34953   {
34954     try {
34955       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34956     } catch (std::out_of_range& e) {
34957       {
34958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34959       };
34960     } catch (std::exception& e) {
34961       {
34962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34963       };
34964     } catch (Dali::DaliException e) {
34965       {
34966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34967       };
34968     } catch (...) {
34969       {
34970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34971       };
34972     }
34973   }
34974
34975   jresult = result;
34976   return jresult;
34977 }
34978
34979
34980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34982   Dali::Degree *arg2 = 0 ;
34983   Dali::Vector3 *arg3 = 0 ;
34984
34985   arg1 = (Dali::Actor *)jarg1;
34986   arg2 = (Dali::Degree *)jarg2;
34987   if (!arg2) {
34988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34989     return ;
34990   }
34991   arg3 = (Dali::Vector3 *)jarg3;
34992   if (!arg3) {
34993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34994     return ;
34995   }
34996   {
34997     try {
34998       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34999     } catch (std::out_of_range& e) {
35000       {
35001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35002       };
35003     } catch (std::exception& e) {
35004       {
35005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35006       };
35007     } catch (Dali::DaliException e) {
35008       {
35009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35010       };
35011     } catch (...) {
35012       {
35013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35014       };
35015     }
35016   }
35017
35018 }
35019
35020
35021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35022   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35023   Dali::Radian *arg2 = 0 ;
35024   Dali::Vector3 *arg3 = 0 ;
35025
35026   arg1 = (Dali::Actor *)jarg1;
35027   arg2 = (Dali::Radian *)jarg2;
35028   if (!arg2) {
35029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35030     return ;
35031   }
35032   arg3 = (Dali::Vector3 *)jarg3;
35033   if (!arg3) {
35034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35035     return ;
35036   }
35037   {
35038     try {
35039       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35040     } catch (std::out_of_range& e) {
35041       {
35042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35043       };
35044     } catch (std::exception& e) {
35045       {
35046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35047       };
35048     } catch (Dali::DaliException e) {
35049       {
35050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35051       };
35052     } catch (...) {
35053       {
35054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35055       };
35056     }
35057   }
35058
35059 }
35060
35061
35062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35063   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35064   Dali::Quaternion *arg2 = 0 ;
35065
35066   arg1 = (Dali::Actor *)jarg1;
35067   arg2 = (Dali::Quaternion *)jarg2;
35068   if (!arg2) {
35069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35070     return ;
35071   }
35072   {
35073     try {
35074       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35075     } catch (std::out_of_range& e) {
35076       {
35077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35078       };
35079     } catch (std::exception& e) {
35080       {
35081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35082       };
35083     } catch (Dali::DaliException e) {
35084       {
35085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35086       };
35087     } catch (...) {
35088       {
35089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35090       };
35091     }
35092   }
35093
35094 }
35095
35096
35097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35098   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35099   Dali::Degree *arg2 = 0 ;
35100   Dali::Vector3 *arg3 = 0 ;
35101
35102   arg1 = (Dali::Actor *)jarg1;
35103   arg2 = (Dali::Degree *)jarg2;
35104   if (!arg2) {
35105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35106     return ;
35107   }
35108   arg3 = (Dali::Vector3 *)jarg3;
35109   if (!arg3) {
35110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35111     return ;
35112   }
35113   {
35114     try {
35115       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35116     } catch (std::out_of_range& e) {
35117       {
35118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35119       };
35120     } catch (std::exception& e) {
35121       {
35122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35123       };
35124     } catch (Dali::DaliException e) {
35125       {
35126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35127       };
35128     } catch (...) {
35129       {
35130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35131       };
35132     }
35133   }
35134
35135 }
35136
35137
35138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35139   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35140   Dali::Radian *arg2 = 0 ;
35141   Dali::Vector3 *arg3 = 0 ;
35142
35143   arg1 = (Dali::Actor *)jarg1;
35144   arg2 = (Dali::Radian *)jarg2;
35145   if (!arg2) {
35146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35147     return ;
35148   }
35149   arg3 = (Dali::Vector3 *)jarg3;
35150   if (!arg3) {
35151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35152     return ;
35153   }
35154   {
35155     try {
35156       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35157     } catch (std::out_of_range& e) {
35158       {
35159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35160       };
35161     } catch (std::exception& e) {
35162       {
35163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35164       };
35165     } catch (Dali::DaliException e) {
35166       {
35167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35168       };
35169     } catch (...) {
35170       {
35171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35172       };
35173     }
35174   }
35175
35176 }
35177
35178
35179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35180   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35181   Dali::Quaternion *arg2 = 0 ;
35182
35183   arg1 = (Dali::Actor *)jarg1;
35184   arg2 = (Dali::Quaternion *)jarg2;
35185   if (!arg2) {
35186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35187     return ;
35188   }
35189   {
35190     try {
35191       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35192     } catch (std::out_of_range& e) {
35193       {
35194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35195       };
35196     } catch (std::exception& e) {
35197       {
35198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35199       };
35200     } catch (Dali::DaliException e) {
35201       {
35202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35203       };
35204     } catch (...) {
35205       {
35206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35207       };
35208     }
35209   }
35210
35211 }
35212
35213
35214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35215   void * jresult ;
35216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35217   Dali::Quaternion result;
35218
35219   arg1 = (Dali::Actor *)jarg1;
35220   {
35221     try {
35222       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35223     } catch (std::out_of_range& e) {
35224       {
35225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35226       };
35227     } catch (std::exception& e) {
35228       {
35229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35230       };
35231     } catch (Dali::DaliException e) {
35232       {
35233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35234       };
35235     } catch (...) {
35236       {
35237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35238       };
35239     }
35240   }
35241
35242   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35243   return jresult;
35244 }
35245
35246
35247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35248   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35249   bool arg2 ;
35250
35251   arg1 = (Dali::Actor *)jarg1;
35252   arg2 = jarg2 ? true : false;
35253   {
35254     try {
35255       (arg1)->SetInheritOrientation(arg2);
35256     } catch (std::out_of_range& e) {
35257       {
35258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35259       };
35260     } catch (std::exception& e) {
35261       {
35262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35263       };
35264     } catch (Dali::DaliException e) {
35265       {
35266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35267       };
35268     } catch (...) {
35269       {
35270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35271       };
35272     }
35273   }
35274
35275 }
35276
35277
35278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35279   unsigned int jresult ;
35280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35281   bool result;
35282
35283   arg1 = (Dali::Actor *)jarg1;
35284   {
35285     try {
35286       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35287     } catch (std::out_of_range& e) {
35288       {
35289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35290       };
35291     } catch (std::exception& e) {
35292       {
35293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35294       };
35295     } catch (Dali::DaliException e) {
35296       {
35297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35298       };
35299     } catch (...) {
35300       {
35301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35302       };
35303     }
35304   }
35305
35306   jresult = result;
35307   return jresult;
35308 }
35309
35310
35311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35312   void * jresult ;
35313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35314   Dali::Quaternion result;
35315
35316   arg1 = (Dali::Actor *)jarg1;
35317   {
35318     try {
35319       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35320     } catch (std::out_of_range& e) {
35321       {
35322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35323       };
35324     } catch (std::exception& e) {
35325       {
35326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35327       };
35328     } catch (Dali::DaliException e) {
35329       {
35330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35331       };
35332     } catch (...) {
35333       {
35334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35335       };
35336     }
35337   }
35338
35339   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35340   return jresult;
35341 }
35342
35343
35344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35346   float arg2 ;
35347
35348   arg1 = (Dali::Actor *)jarg1;
35349   arg2 = (float)jarg2;
35350   {
35351     try {
35352       (arg1)->SetScale(arg2);
35353     } catch (std::out_of_range& e) {
35354       {
35355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35356       };
35357     } catch (std::exception& e) {
35358       {
35359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35360       };
35361     } catch (Dali::DaliException e) {
35362       {
35363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35364       };
35365     } catch (...) {
35366       {
35367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35368       };
35369     }
35370   }
35371
35372 }
35373
35374
35375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35376   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35377   float arg2 ;
35378   float arg3 ;
35379   float arg4 ;
35380
35381   arg1 = (Dali::Actor *)jarg1;
35382   arg2 = (float)jarg2;
35383   arg3 = (float)jarg3;
35384   arg4 = (float)jarg4;
35385   {
35386     try {
35387       (arg1)->SetScale(arg2,arg3,arg4);
35388     } catch (std::out_of_range& e) {
35389       {
35390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35391       };
35392     } catch (std::exception& e) {
35393       {
35394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35395       };
35396     } catch (Dali::DaliException e) {
35397       {
35398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35399       };
35400     } catch (...) {
35401       {
35402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35403       };
35404     }
35405   }
35406
35407 }
35408
35409
35410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35411   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35412   Dali::Vector3 *arg2 = 0 ;
35413
35414   arg1 = (Dali::Actor *)jarg1;
35415   arg2 = (Dali::Vector3 *)jarg2;
35416   if (!arg2) {
35417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35418     return ;
35419   }
35420   {
35421     try {
35422       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35423     } catch (std::out_of_range& e) {
35424       {
35425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35426       };
35427     } catch (std::exception& e) {
35428       {
35429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35430       };
35431     } catch (Dali::DaliException e) {
35432       {
35433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35434       };
35435     } catch (...) {
35436       {
35437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35438       };
35439     }
35440   }
35441
35442 }
35443
35444
35445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35446   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35447   Dali::Vector3 *arg2 = 0 ;
35448
35449   arg1 = (Dali::Actor *)jarg1;
35450   arg2 = (Dali::Vector3 *)jarg2;
35451   if (!arg2) {
35452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35453     return ;
35454   }
35455   {
35456     try {
35457       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35458     } catch (std::out_of_range& e) {
35459       {
35460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35461       };
35462     } catch (std::exception& e) {
35463       {
35464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35465       };
35466     } catch (Dali::DaliException e) {
35467       {
35468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35469       };
35470     } catch (...) {
35471       {
35472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35473       };
35474     }
35475   }
35476
35477 }
35478
35479
35480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35481   void * jresult ;
35482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35483   Dali::Vector3 result;
35484
35485   arg1 = (Dali::Actor *)jarg1;
35486   {
35487     try {
35488       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35489     } catch (std::out_of_range& e) {
35490       {
35491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35492       };
35493     } catch (std::exception& e) {
35494       {
35495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35496       };
35497     } catch (Dali::DaliException e) {
35498       {
35499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35500       };
35501     } catch (...) {
35502       {
35503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35504       };
35505     }
35506   }
35507
35508   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35509   return jresult;
35510 }
35511
35512
35513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35514   void * jresult ;
35515   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35516   Dali::Vector3 result;
35517
35518   arg1 = (Dali::Actor *)jarg1;
35519   {
35520     try {
35521       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35522     } catch (std::out_of_range& e) {
35523       {
35524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35525       };
35526     } catch (std::exception& e) {
35527       {
35528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35529       };
35530     } catch (Dali::DaliException e) {
35531       {
35532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35533       };
35534     } catch (...) {
35535       {
35536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35537       };
35538     }
35539   }
35540
35541   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35542   return jresult;
35543 }
35544
35545
35546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35547   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35548   bool arg2 ;
35549
35550   arg1 = (Dali::Actor *)jarg1;
35551   arg2 = jarg2 ? true : false;
35552   {
35553     try {
35554       (arg1)->SetInheritScale(arg2);
35555     } catch (std::out_of_range& e) {
35556       {
35557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35558       };
35559     } catch (std::exception& e) {
35560       {
35561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35562       };
35563     } catch (Dali::DaliException e) {
35564       {
35565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35566       };
35567     } catch (...) {
35568       {
35569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35570       };
35571     }
35572   }
35573
35574 }
35575
35576
35577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35578   unsigned int jresult ;
35579   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35580   bool result;
35581
35582   arg1 = (Dali::Actor *)jarg1;
35583   {
35584     try {
35585       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35586     } catch (std::out_of_range& e) {
35587       {
35588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35589       };
35590     } catch (std::exception& e) {
35591       {
35592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35593       };
35594     } catch (Dali::DaliException e) {
35595       {
35596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35597       };
35598     } catch (...) {
35599       {
35600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35601       };
35602     }
35603   }
35604
35605   jresult = result;
35606   return jresult;
35607 }
35608
35609
35610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35611   void * jresult ;
35612   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35613   Dali::Matrix result;
35614
35615   arg1 = (Dali::Actor *)jarg1;
35616   {
35617     try {
35618       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35619     } catch (std::out_of_range& e) {
35620       {
35621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35622       };
35623     } catch (std::exception& e) {
35624       {
35625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35626       };
35627     } catch (Dali::DaliException e) {
35628       {
35629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35630       };
35631     } catch (...) {
35632       {
35633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35634       };
35635     }
35636   }
35637
35638   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35639   return jresult;
35640 }
35641
35642
35643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35644   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35645   bool arg2 ;
35646
35647   arg1 = (Dali::Actor *)jarg1;
35648   arg2 = jarg2 ? true : false;
35649   {
35650     try {
35651       (arg1)->SetVisible(arg2);
35652     } catch (std::out_of_range& e) {
35653       {
35654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35655       };
35656     } catch (std::exception& e) {
35657       {
35658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35659       };
35660     } catch (Dali::DaliException e) {
35661       {
35662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35663       };
35664     } catch (...) {
35665       {
35666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35667       };
35668     }
35669   }
35670
35671 }
35672
35673
35674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35675   unsigned int jresult ;
35676   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35677   bool result;
35678
35679   arg1 = (Dali::Actor *)jarg1;
35680   {
35681     try {
35682       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35683     } catch (std::out_of_range& e) {
35684       {
35685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35686       };
35687     } catch (std::exception& e) {
35688       {
35689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35690       };
35691     } catch (Dali::DaliException e) {
35692       {
35693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35694       };
35695     } catch (...) {
35696       {
35697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35698       };
35699     }
35700   }
35701
35702   jresult = result;
35703   return jresult;
35704 }
35705
35706
35707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35708   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35709   float arg2 ;
35710
35711   arg1 = (Dali::Actor *)jarg1;
35712   arg2 = (float)jarg2;
35713   {
35714     try {
35715       (arg1)->SetOpacity(arg2);
35716     } catch (std::out_of_range& e) {
35717       {
35718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35719       };
35720     } catch (std::exception& e) {
35721       {
35722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35723       };
35724     } catch (Dali::DaliException e) {
35725       {
35726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35727       };
35728     } catch (...) {
35729       {
35730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35731       };
35732     }
35733   }
35734
35735 }
35736
35737
35738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35739   float jresult ;
35740   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35741   float result;
35742
35743   arg1 = (Dali::Actor *)jarg1;
35744   {
35745     try {
35746       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35747     } catch (std::out_of_range& e) {
35748       {
35749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35750       };
35751     } catch (std::exception& e) {
35752       {
35753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35754       };
35755     } catch (Dali::DaliException e) {
35756       {
35757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35758       };
35759     } catch (...) {
35760       {
35761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35762       };
35763     }
35764   }
35765
35766   jresult = result;
35767   return jresult;
35768 }
35769
35770
35771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35772   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35773   Dali::Vector4 *arg2 = 0 ;
35774
35775   arg1 = (Dali::Actor *)jarg1;
35776   arg2 = (Dali::Vector4 *)jarg2;
35777   if (!arg2) {
35778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35779     return ;
35780   }
35781   {
35782     try {
35783       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35784     } catch (std::out_of_range& e) {
35785       {
35786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35787       };
35788     } catch (std::exception& e) {
35789       {
35790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35791       };
35792     } catch (Dali::DaliException e) {
35793       {
35794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35795       };
35796     } catch (...) {
35797       {
35798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35799       };
35800     }
35801   }
35802
35803 }
35804
35805
35806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35807   void * jresult ;
35808   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35809   Dali::Vector4 result;
35810
35811   arg1 = (Dali::Actor *)jarg1;
35812   {
35813     try {
35814       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35815     } catch (std::out_of_range& e) {
35816       {
35817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35818       };
35819     } catch (std::exception& e) {
35820       {
35821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35822       };
35823     } catch (Dali::DaliException e) {
35824       {
35825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35826       };
35827     } catch (...) {
35828       {
35829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35830       };
35831     }
35832   }
35833
35834   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35835   return jresult;
35836 }
35837
35838
35839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35841   Dali::ColorMode arg2 ;
35842
35843   arg1 = (Dali::Actor *)jarg1;
35844   arg2 = (Dali::ColorMode)jarg2;
35845   {
35846     try {
35847       (arg1)->SetColorMode(arg2);
35848     } catch (std::out_of_range& e) {
35849       {
35850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35851       };
35852     } catch (std::exception& e) {
35853       {
35854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35855       };
35856     } catch (Dali::DaliException e) {
35857       {
35858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35859       };
35860     } catch (...) {
35861       {
35862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35863       };
35864     }
35865   }
35866
35867 }
35868
35869
35870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35871   int jresult ;
35872   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35873   Dali::ColorMode result;
35874
35875   arg1 = (Dali::Actor *)jarg1;
35876   {
35877     try {
35878       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35879     } catch (std::out_of_range& e) {
35880       {
35881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35882       };
35883     } catch (std::exception& e) {
35884       {
35885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35886       };
35887     } catch (Dali::DaliException e) {
35888       {
35889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35890       };
35891     } catch (...) {
35892       {
35893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35894       };
35895     }
35896   }
35897
35898   jresult = (int)result;
35899   return jresult;
35900 }
35901
35902
35903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35904   void * jresult ;
35905   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35906   Dali::Vector4 result;
35907
35908   arg1 = (Dali::Actor *)jarg1;
35909   {
35910     try {
35911       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35912     } catch (std::out_of_range& e) {
35913       {
35914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35915       };
35916     } catch (std::exception& e) {
35917       {
35918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35919       };
35920     } catch (Dali::DaliException e) {
35921       {
35922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35923       };
35924     } catch (...) {
35925       {
35926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35927       };
35928     }
35929   }
35930
35931   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35932   return jresult;
35933 }
35934
35935
35936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35938   Dali::DrawMode::Type arg2 ;
35939
35940   arg1 = (Dali::Actor *)jarg1;
35941   arg2 = (Dali::DrawMode::Type)jarg2;
35942   {
35943     try {
35944       (arg1)->SetDrawMode(arg2);
35945     } catch (std::out_of_range& e) {
35946       {
35947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35948       };
35949     } catch (std::exception& e) {
35950       {
35951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35952       };
35953     } catch (Dali::DaliException e) {
35954       {
35955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35956       };
35957     } catch (...) {
35958       {
35959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35960       };
35961     }
35962   }
35963
35964 }
35965
35966
35967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35968   int jresult ;
35969   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35970   Dali::DrawMode::Type result;
35971
35972   arg1 = (Dali::Actor *)jarg1;
35973   {
35974     try {
35975       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35976     } catch (std::out_of_range& e) {
35977       {
35978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35979       };
35980     } catch (std::exception& e) {
35981       {
35982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35983       };
35984     } catch (Dali::DaliException e) {
35985       {
35986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35987       };
35988     } catch (...) {
35989       {
35990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35991       };
35992     }
35993   }
35994
35995   jresult = (int)result;
35996   return jresult;
35997 }
35998
35999
36000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36001   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36002   bool arg2 ;
36003
36004   arg1 = (Dali::Actor *)jarg1;
36005   arg2 = jarg2 ? true : false;
36006   {
36007     try {
36008       (arg1)->SetSensitive(arg2);
36009     } catch (std::out_of_range& e) {
36010       {
36011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36012       };
36013     } catch (std::exception& e) {
36014       {
36015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36016       };
36017     } catch (Dali::DaliException e) {
36018       {
36019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36020       };
36021     } catch (...) {
36022       {
36023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36024       };
36025     }
36026   }
36027
36028 }
36029
36030
36031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36032   unsigned int jresult ;
36033   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36034   bool result;
36035
36036   arg1 = (Dali::Actor *)jarg1;
36037   {
36038     try {
36039       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36040     } catch (std::out_of_range& e) {
36041       {
36042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36043       };
36044     } catch (std::exception& e) {
36045       {
36046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36047       };
36048     } catch (Dali::DaliException e) {
36049       {
36050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36051       };
36052     } catch (...) {
36053       {
36054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36055       };
36056     }
36057   }
36058
36059   jresult = result;
36060   return jresult;
36061 }
36062
36063
36064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36065   unsigned int jresult ;
36066   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36067   float *arg2 = 0 ;
36068   float *arg3 = 0 ;
36069   float arg4 ;
36070   float arg5 ;
36071   bool result;
36072
36073   arg1 = (Dali::Actor *)jarg1;
36074   arg2 = (float *)jarg2;
36075   arg3 = (float *)jarg3;
36076   arg4 = (float)jarg4;
36077   arg5 = (float)jarg5;
36078   {
36079     try {
36080       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36081     } catch (std::out_of_range& e) {
36082       {
36083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36084       };
36085     } catch (std::exception& e) {
36086       {
36087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36088       };
36089     } catch (Dali::DaliException e) {
36090       {
36091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36092       };
36093     } catch (...) {
36094       {
36095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36096       };
36097     }
36098   }
36099
36100   jresult = result;
36101   return jresult;
36102 }
36103
36104
36105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36106   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36107   bool arg2 ;
36108
36109   arg1 = (Dali::Actor *)jarg1;
36110   arg2 = jarg2 ? true : false;
36111   {
36112     try {
36113       (arg1)->SetLeaveRequired(arg2);
36114     } catch (std::out_of_range& e) {
36115       {
36116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36117       };
36118     } catch (std::exception& e) {
36119       {
36120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36121       };
36122     } catch (Dali::DaliException e) {
36123       {
36124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36125       };
36126     } catch (...) {
36127       {
36128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36129       };
36130     }
36131   }
36132
36133 }
36134
36135
36136 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36137   unsigned int jresult ;
36138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36139   bool result;
36140
36141   arg1 = (Dali::Actor *)jarg1;
36142   {
36143     try {
36144       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36145     } catch (std::out_of_range& e) {
36146       {
36147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36148       };
36149     } catch (std::exception& e) {
36150       {
36151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36152       };
36153     } catch (Dali::DaliException e) {
36154       {
36155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36156       };
36157     } catch (...) {
36158       {
36159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36160       };
36161     }
36162   }
36163
36164   jresult = result;
36165   return jresult;
36166 }
36167
36168
36169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36170   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36171   bool arg2 ;
36172
36173   arg1 = (Dali::Actor *)jarg1;
36174   arg2 = jarg2 ? true : false;
36175   {
36176     try {
36177       (arg1)->SetKeyboardFocusable(arg2);
36178     } catch (std::out_of_range& e) {
36179       {
36180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36181       };
36182     } catch (std::exception& e) {
36183       {
36184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36185       };
36186     } catch (Dali::DaliException e) {
36187       {
36188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36189       };
36190     } catch (...) {
36191       {
36192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36193       };
36194     }
36195   }
36196
36197 }
36198
36199
36200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36201   unsigned int jresult ;
36202   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36203   bool result;
36204
36205   arg1 = (Dali::Actor *)jarg1;
36206   {
36207     try {
36208       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36209     } catch (std::out_of_range& e) {
36210       {
36211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36212       };
36213     } catch (std::exception& e) {
36214       {
36215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36216       };
36217     } catch (Dali::DaliException e) {
36218       {
36219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36220       };
36221     } catch (...) {
36222       {
36223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36224       };
36225     }
36226   }
36227
36228   jresult = result;
36229   return jresult;
36230 }
36231
36232
36233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36234   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36235   Dali::ResizePolicy::Type arg2 ;
36236   Dali::Dimension::Type arg3 ;
36237
36238   arg1 = (Dali::Actor *)jarg1;
36239   arg2 = (Dali::ResizePolicy::Type)jarg2;
36240   arg3 = (Dali::Dimension::Type)jarg3;
36241   {
36242     try {
36243       (arg1)->SetResizePolicy(arg2,arg3);
36244     } catch (std::out_of_range& e) {
36245       {
36246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36247       };
36248     } catch (std::exception& e) {
36249       {
36250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36251       };
36252     } catch (Dali::DaliException e) {
36253       {
36254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36255       };
36256     } catch (...) {
36257       {
36258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36259       };
36260     }
36261   }
36262
36263 }
36264
36265
36266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36267   int jresult ;
36268   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36269   Dali::Dimension::Type arg2 ;
36270   Dali::ResizePolicy::Type result;
36271
36272   arg1 = (Dali::Actor *)jarg1;
36273   arg2 = (Dali::Dimension::Type)jarg2;
36274   {
36275     try {
36276       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36277     } catch (std::out_of_range& e) {
36278       {
36279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36280       };
36281     } catch (std::exception& e) {
36282       {
36283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36284       };
36285     } catch (Dali::DaliException e) {
36286       {
36287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36288       };
36289     } catch (...) {
36290       {
36291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36292       };
36293     }
36294   }
36295
36296   jresult = (int)result;
36297   return jresult;
36298 }
36299
36300
36301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36302   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36303   Dali::SizeScalePolicy::Type arg2 ;
36304
36305   arg1 = (Dali::Actor *)jarg1;
36306   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36307   {
36308     try {
36309       (arg1)->SetSizeScalePolicy(arg2);
36310     } catch (std::out_of_range& e) {
36311       {
36312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36313       };
36314     } catch (std::exception& e) {
36315       {
36316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36317       };
36318     } catch (Dali::DaliException e) {
36319       {
36320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36321       };
36322     } catch (...) {
36323       {
36324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36325       };
36326     }
36327   }
36328
36329 }
36330
36331
36332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36333   int jresult ;
36334   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36335   Dali::SizeScalePolicy::Type result;
36336
36337   arg1 = (Dali::Actor *)jarg1;
36338   {
36339     try {
36340       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36341     } catch (std::out_of_range& e) {
36342       {
36343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36344       };
36345     } catch (std::exception& e) {
36346       {
36347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36348       };
36349     } catch (Dali::DaliException e) {
36350       {
36351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36352       };
36353     } catch (...) {
36354       {
36355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36356       };
36357     }
36358   }
36359
36360   jresult = (int)result;
36361   return jresult;
36362 }
36363
36364
36365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36366   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36367   Dali::Vector3 *arg2 = 0 ;
36368
36369   arg1 = (Dali::Actor *)jarg1;
36370   arg2 = (Dali::Vector3 *)jarg2;
36371   if (!arg2) {
36372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36373     return ;
36374   }
36375   {
36376     try {
36377       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36378     } catch (std::out_of_range& e) {
36379       {
36380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36381       };
36382     } catch (std::exception& e) {
36383       {
36384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36385       };
36386     } catch (Dali::DaliException e) {
36387       {
36388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36389       };
36390     } catch (...) {
36391       {
36392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36393       };
36394     }
36395   }
36396
36397 }
36398
36399
36400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36401   void * jresult ;
36402   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36403   Dali::Vector3 result;
36404
36405   arg1 = (Dali::Actor *)jarg1;
36406   {
36407     try {
36408       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36409     } catch (std::out_of_range& e) {
36410       {
36411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36412       };
36413     } catch (std::exception& e) {
36414       {
36415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36416       };
36417     } catch (Dali::DaliException e) {
36418       {
36419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36420       };
36421     } catch (...) {
36422       {
36423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36424       };
36425     }
36426   }
36427
36428   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36429   return jresult;
36430 }
36431
36432
36433 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36434   float jresult ;
36435   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36436   float arg2 ;
36437   float result;
36438
36439   arg1 = (Dali::Actor *)jarg1;
36440   arg2 = (float)jarg2;
36441   {
36442     try {
36443       result = (float)(arg1)->GetHeightForWidth(arg2);
36444     } catch (std::out_of_range& e) {
36445       {
36446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36447       };
36448     } catch (std::exception& e) {
36449       {
36450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36451       };
36452     } catch (Dali::DaliException e) {
36453       {
36454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36455       };
36456     } catch (...) {
36457       {
36458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36459       };
36460     }
36461   }
36462
36463   jresult = result;
36464   return jresult;
36465 }
36466
36467
36468 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36469   float jresult ;
36470   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36471   float arg2 ;
36472   float result;
36473
36474   arg1 = (Dali::Actor *)jarg1;
36475   arg2 = (float)jarg2;
36476   {
36477     try {
36478       result = (float)(arg1)->GetWidthForHeight(arg2);
36479     } catch (std::out_of_range& e) {
36480       {
36481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36482       };
36483     } catch (std::exception& e) {
36484       {
36485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36486       };
36487     } catch (Dali::DaliException e) {
36488       {
36489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36490       };
36491     } catch (...) {
36492       {
36493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36494       };
36495     }
36496   }
36497
36498   jresult = result;
36499   return jresult;
36500 }
36501
36502
36503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36504   float jresult ;
36505   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36506   Dali::Dimension::Type arg2 ;
36507   float result;
36508
36509   arg1 = (Dali::Actor *)jarg1;
36510   arg2 = (Dali::Dimension::Type)jarg2;
36511   {
36512     try {
36513       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36514     } catch (std::out_of_range& e) {
36515       {
36516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36517       };
36518     } catch (std::exception& e) {
36519       {
36520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36521       };
36522     } catch (Dali::DaliException e) {
36523       {
36524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36525       };
36526     } catch (...) {
36527       {
36528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36529       };
36530     }
36531   }
36532
36533   jresult = result;
36534   return jresult;
36535 }
36536
36537
36538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36539   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36540   Dali::Padding *arg2 = 0 ;
36541
36542   arg1 = (Dali::Actor *)jarg1;
36543   arg2 = (Dali::Padding *)jarg2;
36544   if (!arg2) {
36545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36546     return ;
36547   }
36548   {
36549     try {
36550       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36551     } catch (std::out_of_range& e) {
36552       {
36553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36554       };
36555     } catch (std::exception& e) {
36556       {
36557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36558       };
36559     } catch (Dali::DaliException e) {
36560       {
36561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36562       };
36563     } catch (...) {
36564       {
36565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36566       };
36567     }
36568   }
36569
36570 }
36571
36572
36573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36574   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36575   Dali::Padding *arg2 = 0 ;
36576
36577   arg1 = (Dali::Actor *)jarg1;
36578   arg2 = (Dali::Padding *)jarg2;
36579   if (!arg2) {
36580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36581     return ;
36582   }
36583   {
36584     try {
36585       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36586     } catch (std::out_of_range& e) {
36587       {
36588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36589       };
36590     } catch (std::exception& e) {
36591       {
36592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36593       };
36594     } catch (Dali::DaliException e) {
36595       {
36596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36597       };
36598     } catch (...) {
36599       {
36600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36601       };
36602     }
36603   }
36604
36605 }
36606
36607
36608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36609   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36610   Dali::Vector2 *arg2 = 0 ;
36611
36612   arg1 = (Dali::Actor *)jarg1;
36613   arg2 = (Dali::Vector2 *)jarg2;
36614   if (!arg2) {
36615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36616     return ;
36617   }
36618   {
36619     try {
36620       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36621     } catch (std::out_of_range& e) {
36622       {
36623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36624       };
36625     } catch (std::exception& e) {
36626       {
36627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36628       };
36629     } catch (Dali::DaliException e) {
36630       {
36631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36632       };
36633     } catch (...) {
36634       {
36635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36636       };
36637     }
36638   }
36639
36640 }
36641
36642
36643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36644   void * jresult ;
36645   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36646   Dali::Vector2 result;
36647
36648   arg1 = (Dali::Actor *)jarg1;
36649   {
36650     try {
36651       result = (arg1)->GetMinimumSize();
36652     } catch (std::out_of_range& e) {
36653       {
36654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36655       };
36656     } catch (std::exception& e) {
36657       {
36658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36659       };
36660     } catch (Dali::DaliException e) {
36661       {
36662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36663       };
36664     } catch (...) {
36665       {
36666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36667       };
36668     }
36669   }
36670
36671   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36672   return jresult;
36673 }
36674
36675
36676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36677   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36678   Dali::Vector2 *arg2 = 0 ;
36679
36680   arg1 = (Dali::Actor *)jarg1;
36681   arg2 = (Dali::Vector2 *)jarg2;
36682   if (!arg2) {
36683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36684     return ;
36685   }
36686   {
36687     try {
36688       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36689     } catch (std::out_of_range& e) {
36690       {
36691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36692       };
36693     } catch (std::exception& e) {
36694       {
36695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36696       };
36697     } catch (Dali::DaliException e) {
36698       {
36699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36700       };
36701     } catch (...) {
36702       {
36703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36704       };
36705     }
36706   }
36707
36708 }
36709
36710
36711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36712   void * jresult ;
36713   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36714   Dali::Vector2 result;
36715
36716   arg1 = (Dali::Actor *)jarg1;
36717   {
36718     try {
36719       result = (arg1)->GetMaximumSize();
36720     } catch (std::out_of_range& e) {
36721       {
36722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36723       };
36724     } catch (std::exception& e) {
36725       {
36726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36727       };
36728     } catch (Dali::DaliException e) {
36729       {
36730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36731       };
36732     } catch (...) {
36733       {
36734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36735       };
36736     }
36737   }
36738
36739   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36740   return jresult;
36741 }
36742
36743
36744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36745   int jresult ;
36746   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36747   int result;
36748
36749   arg1 = (Dali::Actor *)jarg1;
36750   {
36751     try {
36752       result = (int)(arg1)->GetHierarchyDepth();
36753       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36754     } catch (std::out_of_range& e) {
36755       {
36756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36757       };
36758     } catch (std::exception& e) {
36759       {
36760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36761       };
36762     } catch (Dali::DaliException e) {
36763       {
36764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36765       };
36766     } catch (...) {
36767       {
36768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36769       };
36770     }
36771   }
36772
36773   jresult = result;
36774   return jresult;
36775 }
36776
36777
36778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36779   unsigned int jresult ;
36780   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36781   Dali::Renderer *arg2 = 0 ;
36782   unsigned int result;
36783
36784   arg1 = (Dali::Actor *)jarg1;
36785   arg2 = (Dali::Renderer *)jarg2;
36786   if (!arg2) {
36787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36788     return 0;
36789   }
36790   {
36791     try {
36792       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36793     } catch (std::out_of_range& e) {
36794       {
36795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36796       };
36797     } catch (std::exception& e) {
36798       {
36799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36800       };
36801     } catch (Dali::DaliException e) {
36802       {
36803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36804       };
36805     } catch (...) {
36806       {
36807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36808       };
36809     }
36810   }
36811
36812   jresult = result;
36813   return jresult;
36814 }
36815
36816
36817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36818   unsigned int jresult ;
36819   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36820   unsigned int result;
36821
36822   arg1 = (Dali::Actor *)jarg1;
36823   {
36824     try {
36825       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36826     } catch (std::out_of_range& e) {
36827       {
36828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36829       };
36830     } catch (std::exception& e) {
36831       {
36832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36833       };
36834     } catch (Dali::DaliException e) {
36835       {
36836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36837       };
36838     } catch (...) {
36839       {
36840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36841       };
36842     }
36843   }
36844
36845   jresult = result;
36846   return jresult;
36847 }
36848
36849
36850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36851   void * jresult ;
36852   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36853   unsigned int arg2 ;
36854   Dali::Renderer result;
36855
36856   arg1 = (Dali::Actor *)jarg1;
36857   arg2 = (unsigned int)jarg2;
36858   {
36859     try {
36860       result = (arg1)->GetRendererAt(arg2);
36861     } catch (std::out_of_range& e) {
36862       {
36863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36864       };
36865     } catch (std::exception& e) {
36866       {
36867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36868       };
36869     } catch (Dali::DaliException e) {
36870       {
36871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36872       };
36873     } catch (...) {
36874       {
36875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36876       };
36877     }
36878   }
36879
36880   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36881   return jresult;
36882 }
36883
36884
36885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36886   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36887   Dali::Renderer *arg2 = 0 ;
36888
36889   arg1 = (Dali::Actor *)jarg1;
36890   arg2 = (Dali::Renderer *)jarg2;
36891   if (!arg2) {
36892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36893     return ;
36894   }
36895   {
36896     try {
36897       (arg1)->RemoveRenderer(*arg2);
36898     } catch (std::out_of_range& e) {
36899       {
36900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36901       };
36902     } catch (std::exception& e) {
36903       {
36904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36905       };
36906     } catch (Dali::DaliException e) {
36907       {
36908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36909       };
36910     } catch (...) {
36911       {
36912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36913       };
36914     }
36915   }
36916
36917 }
36918
36919
36920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36921   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36922   unsigned int arg2 ;
36923
36924   arg1 = (Dali::Actor *)jarg1;
36925   arg2 = (unsigned int)jarg2;
36926   {
36927     try {
36928       (arg1)->RemoveRenderer(arg2);
36929     } catch (std::out_of_range& e) {
36930       {
36931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36932       };
36933     } catch (std::exception& e) {
36934       {
36935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36936       };
36937     } catch (Dali::DaliException e) {
36938       {
36939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36940       };
36941     } catch (...) {
36942       {
36943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36944       };
36945     }
36946   }
36947
36948 }
36949
36950
36951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36952   void * jresult ;
36953   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36954   Dali::Actor::TouchSignalType *result = 0 ;
36955
36956   arg1 = (Dali::Actor *)jarg1;
36957   {
36958     try {
36959       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36960     } catch (std::out_of_range& e) {
36961       {
36962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36963       };
36964     } catch (std::exception& e) {
36965       {
36966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36967       };
36968     } catch (Dali::DaliException e) {
36969       {
36970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36971       };
36972     } catch (...) {
36973       {
36974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36975       };
36976     }
36977   }
36978
36979   jresult = (void *)result;
36980   return jresult;
36981 }
36982
36983
36984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36985   void * jresult ;
36986   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36987   Dali::Actor::TouchDataSignalType *result = 0 ;
36988
36989   arg1 = (Dali::Actor *)jarg1;
36990   {
36991     try {
36992       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36993     } catch (std::out_of_range& e) {
36994       {
36995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36996       };
36997     } catch (std::exception& e) {
36998       {
36999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37000       };
37001     } catch (Dali::DaliException e) {
37002       {
37003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37004       };
37005     } catch (...) {
37006       {
37007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37008       };
37009     }
37010   }
37011
37012   jresult = (void *)result;
37013   return jresult;
37014 }
37015
37016
37017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37018   void * jresult ;
37019   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37020   Dali::Actor::HoverSignalType *result = 0 ;
37021
37022   arg1 = (Dali::Actor *)jarg1;
37023   {
37024     try {
37025       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37026     } catch (std::out_of_range& e) {
37027       {
37028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37029       };
37030     } catch (std::exception& e) {
37031       {
37032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37033       };
37034     } catch (Dali::DaliException e) {
37035       {
37036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37037       };
37038     } catch (...) {
37039       {
37040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37041       };
37042     }
37043   }
37044
37045   jresult = (void *)result;
37046   return jresult;
37047 }
37048
37049
37050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37051   void * jresult ;
37052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37053   Dali::Actor::WheelEventSignalType *result = 0 ;
37054
37055   arg1 = (Dali::Actor *)jarg1;
37056   {
37057     try {
37058       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37059     } catch (std::out_of_range& e) {
37060       {
37061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37062       };
37063     } catch (std::exception& e) {
37064       {
37065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37066       };
37067     } catch (Dali::DaliException e) {
37068       {
37069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37070       };
37071     } catch (...) {
37072       {
37073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37074       };
37075     }
37076   }
37077
37078   jresult = (void *)result;
37079   return jresult;
37080 }
37081
37082
37083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37084   void * jresult ;
37085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37086   Dali::Actor::OnStageSignalType *result = 0 ;
37087
37088   arg1 = (Dali::Actor *)jarg1;
37089   {
37090     try {
37091       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37092     } catch (std::out_of_range& e) {
37093       {
37094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37095       };
37096     } catch (std::exception& e) {
37097       {
37098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37099       };
37100     } catch (Dali::DaliException e) {
37101       {
37102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37103       };
37104     } catch (...) {
37105       {
37106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37107       };
37108     }
37109   }
37110
37111   jresult = (void *)result;
37112   return jresult;
37113 }
37114
37115
37116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37117   void * jresult ;
37118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37119   Dali::Actor::OffStageSignalType *result = 0 ;
37120
37121   arg1 = (Dali::Actor *)jarg1;
37122   {
37123     try {
37124       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37125     } catch (std::out_of_range& e) {
37126       {
37127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37128       };
37129     } catch (std::exception& e) {
37130       {
37131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37132       };
37133     } catch (Dali::DaliException e) {
37134       {
37135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37136       };
37137     } catch (...) {
37138       {
37139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37140       };
37141     }
37142   }
37143
37144   jresult = (void *)result;
37145   return jresult;
37146 }
37147
37148
37149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37150   void * jresult ;
37151   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37152   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37153
37154   arg1 = (Dali::Actor *)jarg1;
37155   {
37156     try {
37157       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37158     } catch (std::out_of_range& e) {
37159       {
37160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37161       };
37162     } catch (std::exception& e) {
37163       {
37164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37165       };
37166     } catch (Dali::DaliException e) {
37167       {
37168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37169       };
37170     } catch (...) {
37171       {
37172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37173       };
37174     }
37175   }
37176
37177   jresult = (void *)result;
37178   return jresult;
37179 }
37180
37181
37182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37183   Dali::Actor *arg1 = 0 ;
37184
37185   arg1 = (Dali::Actor *)jarg1;
37186   if (!arg1) {
37187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37188     return ;
37189   }
37190   {
37191     try {
37192       Dali::UnparentAndReset(*arg1);
37193     } catch (std::out_of_range& e) {
37194       {
37195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37196       };
37197     } catch (std::exception& e) {
37198       {
37199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37200       };
37201     } catch (Dali::DaliException e) {
37202       {
37203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37204       };
37205     } catch (...) {
37206       {
37207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37208       };
37209     }
37210   }
37211
37212 }
37213
37214
37215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37216   int jresult ;
37217   int result;
37218
37219   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37220   jresult = (int)result;
37221   return jresult;
37222 }
37223
37224
37225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37226   int jresult ;
37227   int result;
37228
37229   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37230   jresult = (int)result;
37231   return jresult;
37232 }
37233
37234
37235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37236   int jresult ;
37237   int result;
37238
37239   result = (int)Dali::Layer::Property::BEHAVIOR;
37240   jresult = (int)result;
37241   return jresult;
37242 }
37243
37244
37245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37246   void * jresult ;
37247   Dali::Layer::Property *result = 0 ;
37248
37249   {
37250     try {
37251       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37252     } catch (std::out_of_range& e) {
37253       {
37254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37255       };
37256     } catch (std::exception& e) {
37257       {
37258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37259       };
37260     } catch (Dali::DaliException e) {
37261       {
37262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37263       };
37264     } catch (...) {
37265       {
37266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37267       };
37268     }
37269   }
37270
37271   jresult = (void *)result;
37272   return jresult;
37273 }
37274
37275
37276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37277   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37278
37279   arg1 = (Dali::Layer::Property *)jarg1;
37280   {
37281     try {
37282       delete arg1;
37283     } catch (std::out_of_range& e) {
37284       {
37285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37286       };
37287     } catch (std::exception& e) {
37288       {
37289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37290       };
37291     } catch (Dali::DaliException e) {
37292       {
37293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37294       };
37295     } catch (...) {
37296       {
37297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37298       };
37299     }
37300   }
37301
37302 }
37303
37304
37305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37306   void * jresult ;
37307   Dali::Layer *result = 0 ;
37308
37309   {
37310     try {
37311       result = (Dali::Layer *)new Dali::Layer();
37312     } catch (std::out_of_range& e) {
37313       {
37314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37315       };
37316     } catch (std::exception& e) {
37317       {
37318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37319       };
37320     } catch (Dali::DaliException e) {
37321       {
37322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37323       };
37324     } catch (...) {
37325       {
37326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37327       };
37328     }
37329   }
37330
37331   jresult = (void *)result;
37332   return jresult;
37333 }
37334
37335
37336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37337   void * jresult ;
37338   Dali::Layer result;
37339
37340   {
37341     try {
37342       result = Dali::Layer::New();
37343     } catch (std::out_of_range& e) {
37344       {
37345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37346       };
37347     } catch (std::exception& e) {
37348       {
37349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37350       };
37351     } catch (Dali::DaliException e) {
37352       {
37353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37354       };
37355     } catch (...) {
37356       {
37357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37358       };
37359     }
37360   }
37361
37362   jresult = new Dali::Layer((const Dali::Layer &)result);
37363   return jresult;
37364 }
37365
37366
37367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37368   void * jresult ;
37369   Dali::BaseHandle arg1 ;
37370   Dali::BaseHandle *argp1 ;
37371   Dali::Layer result;
37372
37373   argp1 = (Dali::BaseHandle *)jarg1;
37374   if (!argp1) {
37375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37376     return 0;
37377   }
37378   arg1 = *argp1;
37379   {
37380     try {
37381       result = Dali::Layer::DownCast(arg1);
37382     } catch (std::out_of_range& e) {
37383       {
37384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37385       };
37386     } catch (std::exception& e) {
37387       {
37388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37389       };
37390     } catch (Dali::DaliException e) {
37391       {
37392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37393       };
37394     } catch (...) {
37395       {
37396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37397       };
37398     }
37399   }
37400
37401   jresult = new Dali::Layer((const Dali::Layer &)result);
37402   return jresult;
37403 }
37404
37405
37406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37407   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37408
37409   arg1 = (Dali::Layer *)jarg1;
37410   {
37411     try {
37412       delete arg1;
37413     } catch (std::out_of_range& e) {
37414       {
37415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37416       };
37417     } catch (std::exception& e) {
37418       {
37419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37420       };
37421     } catch (Dali::DaliException e) {
37422       {
37423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37424       };
37425     } catch (...) {
37426       {
37427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37428       };
37429     }
37430   }
37431
37432 }
37433
37434
37435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37436   void * jresult ;
37437   Dali::Layer *arg1 = 0 ;
37438   Dali::Layer *result = 0 ;
37439
37440   arg1 = (Dali::Layer *)jarg1;
37441   if (!arg1) {
37442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37443     return 0;
37444   }
37445   {
37446     try {
37447       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37448     } catch (std::out_of_range& e) {
37449       {
37450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37451       };
37452     } catch (std::exception& e) {
37453       {
37454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37455       };
37456     } catch (Dali::DaliException e) {
37457       {
37458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37459       };
37460     } catch (...) {
37461       {
37462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37463       };
37464     }
37465   }
37466
37467   jresult = (void *)result;
37468   return jresult;
37469 }
37470
37471
37472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37473   void * jresult ;
37474   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37475   Dali::Layer *arg2 = 0 ;
37476   Dali::Layer *result = 0 ;
37477
37478   arg1 = (Dali::Layer *)jarg1;
37479   arg2 = (Dali::Layer *)jarg2;
37480   if (!arg2) {
37481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37482     return 0;
37483   }
37484   {
37485     try {
37486       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37487     } catch (std::out_of_range& e) {
37488       {
37489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37490       };
37491     } catch (std::exception& e) {
37492       {
37493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37494       };
37495     } catch (Dali::DaliException e) {
37496       {
37497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37498       };
37499     } catch (...) {
37500       {
37501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37502       };
37503     }
37504   }
37505
37506   jresult = (void *)result;
37507   return jresult;
37508 }
37509
37510
37511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37512   unsigned int jresult ;
37513   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37514   unsigned int result;
37515
37516   arg1 = (Dali::Layer *)jarg1;
37517   {
37518     try {
37519       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37520     } catch (std::out_of_range& e) {
37521       {
37522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37523       };
37524     } catch (std::exception& e) {
37525       {
37526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37527       };
37528     } catch (Dali::DaliException e) {
37529       {
37530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37531       };
37532     } catch (...) {
37533       {
37534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37535       };
37536     }
37537   }
37538
37539   jresult = result;
37540   return jresult;
37541 }
37542
37543
37544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37545   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37546
37547   arg1 = (Dali::Layer *)jarg1;
37548   {
37549     try {
37550       (arg1)->Raise();
37551     } catch (std::out_of_range& e) {
37552       {
37553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37554       };
37555     } catch (std::exception& e) {
37556       {
37557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37558       };
37559     } catch (Dali::DaliException e) {
37560       {
37561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37562       };
37563     } catch (...) {
37564       {
37565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37566       };
37567     }
37568   }
37569
37570 }
37571
37572
37573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37574   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37575
37576   arg1 = (Dali::Layer *)jarg1;
37577   {
37578     try {
37579       (arg1)->Lower();
37580     } catch (std::out_of_range& e) {
37581       {
37582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37583       };
37584     } catch (std::exception& e) {
37585       {
37586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37587       };
37588     } catch (Dali::DaliException e) {
37589       {
37590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37591       };
37592     } catch (...) {
37593       {
37594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37595       };
37596     }
37597   }
37598
37599 }
37600
37601
37602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37603   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37604   Dali::Layer arg2 ;
37605   Dali::Layer *argp2 ;
37606
37607   arg1 = (Dali::Layer *)jarg1;
37608   argp2 = (Dali::Layer *)jarg2;
37609   if (!argp2) {
37610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37611     return ;
37612   }
37613   arg2 = *argp2;
37614   {
37615     try {
37616       (arg1)->RaiseAbove(arg2);
37617     } catch (std::out_of_range& e) {
37618       {
37619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37620       };
37621     } catch (std::exception& e) {
37622       {
37623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37624       };
37625     } catch (Dali::DaliException e) {
37626       {
37627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37628       };
37629     } catch (...) {
37630       {
37631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37632       };
37633     }
37634   }
37635
37636 }
37637
37638
37639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37640   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37641   Dali::Layer arg2 ;
37642   Dali::Layer *argp2 ;
37643
37644   arg1 = (Dali::Layer *)jarg1;
37645   argp2 = (Dali::Layer *)jarg2;
37646   if (!argp2) {
37647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37648     return ;
37649   }
37650   arg2 = *argp2;
37651   {
37652     try {
37653       (arg1)->LowerBelow(arg2);
37654     } catch (std::out_of_range& e) {
37655       {
37656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37657       };
37658     } catch (std::exception& e) {
37659       {
37660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37661       };
37662     } catch (Dali::DaliException e) {
37663       {
37664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37665       };
37666     } catch (...) {
37667       {
37668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37669       };
37670     }
37671   }
37672
37673 }
37674
37675
37676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37677   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37678
37679   arg1 = (Dali::Layer *)jarg1;
37680   {
37681     try {
37682       (arg1)->RaiseToTop();
37683     } catch (std::out_of_range& e) {
37684       {
37685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37686       };
37687     } catch (std::exception& e) {
37688       {
37689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37690       };
37691     } catch (Dali::DaliException e) {
37692       {
37693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37694       };
37695     } catch (...) {
37696       {
37697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37698       };
37699     }
37700   }
37701
37702 }
37703
37704
37705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37706   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37707
37708   arg1 = (Dali::Layer *)jarg1;
37709   {
37710     try {
37711       (arg1)->LowerToBottom();
37712     } catch (std::out_of_range& e) {
37713       {
37714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37715       };
37716     } catch (std::exception& e) {
37717       {
37718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37719       };
37720     } catch (Dali::DaliException e) {
37721       {
37722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37723       };
37724     } catch (...) {
37725       {
37726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37727       };
37728     }
37729   }
37730
37731 }
37732
37733
37734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37735   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37736   Dali::Layer arg2 ;
37737   Dali::Layer *argp2 ;
37738
37739   arg1 = (Dali::Layer *)jarg1;
37740   argp2 = (Dali::Layer *)jarg2;
37741   if (!argp2) {
37742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37743     return ;
37744   }
37745   arg2 = *argp2;
37746   {
37747     try {
37748       (arg1)->MoveAbove(arg2);
37749     } catch (std::out_of_range& e) {
37750       {
37751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37752       };
37753     } catch (std::exception& e) {
37754       {
37755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37756       };
37757     } catch (Dali::DaliException e) {
37758       {
37759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37760       };
37761     } catch (...) {
37762       {
37763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37764       };
37765     }
37766   }
37767
37768 }
37769
37770
37771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37772   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37773   Dali::Layer arg2 ;
37774   Dali::Layer *argp2 ;
37775
37776   arg1 = (Dali::Layer *)jarg1;
37777   argp2 = (Dali::Layer *)jarg2;
37778   if (!argp2) {
37779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37780     return ;
37781   }
37782   arg2 = *argp2;
37783   {
37784     try {
37785       (arg1)->MoveBelow(arg2);
37786     } catch (std::out_of_range& e) {
37787       {
37788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37789       };
37790     } catch (std::exception& e) {
37791       {
37792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37793       };
37794     } catch (Dali::DaliException e) {
37795       {
37796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37797       };
37798     } catch (...) {
37799       {
37800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37801       };
37802     }
37803   }
37804
37805 }
37806
37807
37808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37809   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37810   Dali::Layer::Behavior arg2 ;
37811
37812   arg1 = (Dali::Layer *)jarg1;
37813   arg2 = (Dali::Layer::Behavior)jarg2;
37814   {
37815     try {
37816       (arg1)->SetBehavior(arg2);
37817     } catch (std::out_of_range& e) {
37818       {
37819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37820       };
37821     } catch (std::exception& e) {
37822       {
37823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37824       };
37825     } catch (Dali::DaliException e) {
37826       {
37827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37828       };
37829     } catch (...) {
37830       {
37831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37832       };
37833     }
37834   }
37835
37836 }
37837
37838
37839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37840   int jresult ;
37841   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37842   Dali::Layer::Behavior result;
37843
37844   arg1 = (Dali::Layer *)jarg1;
37845   {
37846     try {
37847       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37848     } catch (std::out_of_range& e) {
37849       {
37850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37851       };
37852     } catch (std::exception& e) {
37853       {
37854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37855       };
37856     } catch (Dali::DaliException e) {
37857       {
37858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37859       };
37860     } catch (...) {
37861       {
37862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37863       };
37864     }
37865   }
37866
37867   jresult = (int)result;
37868   return jresult;
37869 }
37870
37871
37872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37873   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37874   bool arg2 ;
37875
37876   arg1 = (Dali::Layer *)jarg1;
37877   arg2 = jarg2 ? true : false;
37878   {
37879     try {
37880       (arg1)->SetClipping(arg2);
37881     } catch (std::out_of_range& e) {
37882       {
37883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37884       };
37885     } catch (std::exception& e) {
37886       {
37887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37888       };
37889     } catch (Dali::DaliException e) {
37890       {
37891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37892       };
37893     } catch (...) {
37894       {
37895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37896       };
37897     }
37898   }
37899
37900 }
37901
37902
37903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37904   unsigned int jresult ;
37905   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37906   bool result;
37907
37908   arg1 = (Dali::Layer *)jarg1;
37909   {
37910     try {
37911       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37912     } catch (std::out_of_range& e) {
37913       {
37914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37915       };
37916     } catch (std::exception& e) {
37917       {
37918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37919       };
37920     } catch (Dali::DaliException e) {
37921       {
37922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37923       };
37924     } catch (...) {
37925       {
37926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37927       };
37928     }
37929   }
37930
37931   jresult = result;
37932   return jresult;
37933 }
37934
37935
37936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37937   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37938   int arg2 ;
37939   int arg3 ;
37940   int arg4 ;
37941   int arg5 ;
37942
37943   arg1 = (Dali::Layer *)jarg1;
37944   arg2 = (int)jarg2;
37945   arg3 = (int)jarg3;
37946   arg4 = (int)jarg4;
37947   arg5 = (int)jarg5;
37948   {
37949     try {
37950       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37951     } catch (std::out_of_range& e) {
37952       {
37953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37954       };
37955     } catch (std::exception& e) {
37956       {
37957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37958       };
37959     } catch (Dali::DaliException e) {
37960       {
37961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37962       };
37963     } catch (...) {
37964       {
37965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37966       };
37967     }
37968   }
37969
37970 }
37971
37972
37973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37974   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37975   Dali::ClippingBox arg2 ;
37976   Dali::ClippingBox *argp2 ;
37977
37978   arg1 = (Dali::Layer *)jarg1;
37979   argp2 = (Dali::ClippingBox *)jarg2;
37980   if (!argp2) {
37981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37982     return ;
37983   }
37984   arg2 = *argp2;
37985   {
37986     try {
37987       (arg1)->SetClippingBox(arg2);
37988     } catch (std::out_of_range& e) {
37989       {
37990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37991       };
37992     } catch (std::exception& e) {
37993       {
37994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37995       };
37996     } catch (Dali::DaliException e) {
37997       {
37998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37999       };
38000     } catch (...) {
38001       {
38002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38003       };
38004     }
38005   }
38006
38007 }
38008
38009
38010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38011   void * jresult ;
38012   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38013   Dali::ClippingBox result;
38014
38015   arg1 = (Dali::Layer *)jarg1;
38016   {
38017     try {
38018       result = ((Dali::Layer const *)arg1)->GetClippingBox();
38019     } catch (std::out_of_range& e) {
38020       {
38021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38022       };
38023     } catch (std::exception& e) {
38024       {
38025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38026       };
38027     } catch (Dali::DaliException e) {
38028       {
38029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38030       };
38031     } catch (...) {
38032       {
38033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38034       };
38035     }
38036   }
38037
38038   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38039   return jresult;
38040 }
38041
38042
38043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38044   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38045   bool arg2 ;
38046
38047   arg1 = (Dali::Layer *)jarg1;
38048   arg2 = jarg2 ? true : false;
38049   {
38050     try {
38051       (arg1)->SetDepthTestDisabled(arg2);
38052     } catch (std::out_of_range& e) {
38053       {
38054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38055       };
38056     } catch (std::exception& e) {
38057       {
38058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38059       };
38060     } catch (Dali::DaliException e) {
38061       {
38062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38063       };
38064     } catch (...) {
38065       {
38066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38067       };
38068     }
38069   }
38070
38071 }
38072
38073
38074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38075   unsigned int jresult ;
38076   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38077   bool result;
38078
38079   arg1 = (Dali::Layer *)jarg1;
38080   {
38081     try {
38082       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38083     } catch (std::out_of_range& e) {
38084       {
38085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38086       };
38087     } catch (std::exception& e) {
38088       {
38089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38090       };
38091     } catch (Dali::DaliException e) {
38092       {
38093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38094       };
38095     } catch (...) {
38096       {
38097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38098       };
38099     }
38100   }
38101
38102   jresult = result;
38103   return jresult;
38104 }
38105
38106
38107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38108   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38109   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38110
38111   arg1 = (Dali::Layer *)jarg1;
38112   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38113   {
38114     try {
38115       (arg1)->SetSortFunction(arg2);
38116     } catch (std::out_of_range& e) {
38117       {
38118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38119       };
38120     } catch (std::exception& e) {
38121       {
38122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38123       };
38124     } catch (Dali::DaliException e) {
38125       {
38126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38127       };
38128     } catch (...) {
38129       {
38130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38131       };
38132     }
38133   }
38134
38135 }
38136
38137
38138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38139   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38140   bool arg2 ;
38141
38142   arg1 = (Dali::Layer *)jarg1;
38143   arg2 = jarg2 ? true : false;
38144   {
38145     try {
38146       (arg1)->SetTouchConsumed(arg2);
38147     } catch (std::out_of_range& e) {
38148       {
38149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38150       };
38151     } catch (std::exception& e) {
38152       {
38153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38154       };
38155     } catch (Dali::DaliException e) {
38156       {
38157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38158       };
38159     } catch (...) {
38160       {
38161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38162       };
38163     }
38164   }
38165
38166 }
38167
38168
38169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38170   unsigned int jresult ;
38171   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38172   bool result;
38173
38174   arg1 = (Dali::Layer *)jarg1;
38175   {
38176     try {
38177       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38178     } catch (std::out_of_range& e) {
38179       {
38180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38181       };
38182     } catch (std::exception& e) {
38183       {
38184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38185       };
38186     } catch (Dali::DaliException e) {
38187       {
38188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38189       };
38190     } catch (...) {
38191       {
38192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38193       };
38194     }
38195   }
38196
38197   jresult = result;
38198   return jresult;
38199 }
38200
38201
38202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38203   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38204   bool arg2 ;
38205
38206   arg1 = (Dali::Layer *)jarg1;
38207   arg2 = jarg2 ? true : false;
38208   {
38209     try {
38210       (arg1)->SetHoverConsumed(arg2);
38211     } catch (std::out_of_range& e) {
38212       {
38213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38214       };
38215     } catch (std::exception& e) {
38216       {
38217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38218       };
38219     } catch (Dali::DaliException e) {
38220       {
38221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38222       };
38223     } catch (...) {
38224       {
38225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38226       };
38227     }
38228   }
38229
38230 }
38231
38232
38233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38234   unsigned int jresult ;
38235   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38236   bool result;
38237
38238   arg1 = (Dali::Layer *)jarg1;
38239   {
38240     try {
38241       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38242     } catch (std::out_of_range& e) {
38243       {
38244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38245       };
38246     } catch (std::exception& e) {
38247       {
38248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38249       };
38250     } catch (Dali::DaliException e) {
38251       {
38252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38253       };
38254     } catch (...) {
38255       {
38256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38257       };
38258     }
38259   }
38260
38261   jresult = result;
38262   return jresult;
38263 }
38264
38265
38266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38267   void * jresult ;
38268   Dali::Vector4 *result = 0 ;
38269
38270   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38271   jresult = (void *)result;
38272   return jresult;
38273 }
38274
38275
38276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38277   void * jresult ;
38278   Dali::Vector4 *result = 0 ;
38279
38280   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38281   jresult = (void *)result;
38282   return jresult;
38283 }
38284
38285
38286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38287   void * jresult ;
38288   Dali::Stage *result = 0 ;
38289
38290   {
38291     try {
38292       result = (Dali::Stage *)new Dali::Stage();
38293     } catch (std::out_of_range& e) {
38294       {
38295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38296       };
38297     } catch (std::exception& e) {
38298       {
38299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38300       };
38301     } catch (Dali::DaliException e) {
38302       {
38303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38304       };
38305     } catch (...) {
38306       {
38307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38308       };
38309     }
38310   }
38311
38312   jresult = (void *)result;
38313   return jresult;
38314 }
38315
38316
38317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38318   void * jresult ;
38319   Dali::Stage result;
38320
38321   {
38322     try {
38323       result = Dali::Stage::GetCurrent();
38324     } catch (std::out_of_range& e) {
38325       {
38326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38327       };
38328     } catch (std::exception& e) {
38329       {
38330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38331       };
38332     } catch (Dali::DaliException e) {
38333       {
38334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38335       };
38336     } catch (...) {
38337       {
38338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38339       };
38340     }
38341   }
38342
38343   jresult = new Dali::Stage((const Dali::Stage &)result);
38344   return jresult;
38345 }
38346
38347
38348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38349   unsigned int jresult ;
38350   bool result;
38351
38352   {
38353     try {
38354       result = (bool)Dali::Stage::IsInstalled();
38355     } catch (std::out_of_range& e) {
38356       {
38357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38358       };
38359     } catch (std::exception& e) {
38360       {
38361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38362       };
38363     } catch (Dali::DaliException e) {
38364       {
38365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38366       };
38367     } catch (...) {
38368       {
38369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38370       };
38371     }
38372   }
38373
38374   jresult = result;
38375   return jresult;
38376 }
38377
38378
38379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38380   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38381
38382   arg1 = (Dali::Stage *)jarg1;
38383   {
38384     try {
38385       delete arg1;
38386     } catch (std::out_of_range& e) {
38387       {
38388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38389       };
38390     } catch (std::exception& e) {
38391       {
38392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38393       };
38394     } catch (Dali::DaliException e) {
38395       {
38396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38397       };
38398     } catch (...) {
38399       {
38400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38401       };
38402     }
38403   }
38404
38405 }
38406
38407
38408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38409   void * jresult ;
38410   Dali::Stage *arg1 = 0 ;
38411   Dali::Stage *result = 0 ;
38412
38413   arg1 = (Dali::Stage *)jarg1;
38414   if (!arg1) {
38415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38416     return 0;
38417   }
38418   {
38419     try {
38420       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38421     } catch (std::out_of_range& e) {
38422       {
38423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38424       };
38425     } catch (std::exception& e) {
38426       {
38427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38428       };
38429     } catch (Dali::DaliException e) {
38430       {
38431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38432       };
38433     } catch (...) {
38434       {
38435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38436       };
38437     }
38438   }
38439
38440   jresult = (void *)result;
38441   return jresult;
38442 }
38443
38444
38445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38446   void * jresult ;
38447   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38448   Dali::Stage *arg2 = 0 ;
38449   Dali::Stage *result = 0 ;
38450
38451   arg1 = (Dali::Stage *)jarg1;
38452   arg2 = (Dali::Stage *)jarg2;
38453   if (!arg2) {
38454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38455     return 0;
38456   }
38457   {
38458     try {
38459       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38460     } catch (std::out_of_range& e) {
38461       {
38462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38463       };
38464     } catch (std::exception& e) {
38465       {
38466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38467       };
38468     } catch (Dali::DaliException e) {
38469       {
38470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38471       };
38472     } catch (...) {
38473       {
38474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38475       };
38476     }
38477   }
38478
38479   jresult = (void *)result;
38480   return jresult;
38481 }
38482
38483
38484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38485   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38486   Dali::Actor *arg2 = 0 ;
38487
38488   arg1 = (Dali::Stage *)jarg1;
38489   arg2 = (Dali::Actor *)jarg2;
38490   if (!arg2) {
38491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38492     return ;
38493   }
38494   {
38495     try {
38496       (arg1)->Add(*arg2);
38497     } catch (std::out_of_range& e) {
38498       {
38499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38500       };
38501     } catch (std::exception& e) {
38502       {
38503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38504       };
38505     } catch (Dali::DaliException e) {
38506       {
38507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38508       };
38509     } catch (...) {
38510       {
38511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38512       };
38513     }
38514   }
38515
38516 }
38517
38518
38519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38520   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38521   Dali::Actor *arg2 = 0 ;
38522
38523   arg1 = (Dali::Stage *)jarg1;
38524   arg2 = (Dali::Actor *)jarg2;
38525   if (!arg2) {
38526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38527     return ;
38528   }
38529   {
38530     try {
38531       (arg1)->Remove(*arg2);
38532     } catch (std::out_of_range& e) {
38533       {
38534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38535       };
38536     } catch (std::exception& e) {
38537       {
38538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38539       };
38540     } catch (Dali::DaliException e) {
38541       {
38542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38543       };
38544     } catch (...) {
38545       {
38546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38547       };
38548     }
38549   }
38550
38551 }
38552
38553
38554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38555   void * jresult ;
38556   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38557   Dali::Vector2 result;
38558
38559   arg1 = (Dali::Stage *)jarg1;
38560   {
38561     try {
38562       result = ((Dali::Stage const *)arg1)->GetSize();
38563     } catch (std::out_of_range& e) {
38564       {
38565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38566       };
38567     } catch (std::exception& e) {
38568       {
38569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38570       };
38571     } catch (Dali::DaliException e) {
38572       {
38573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38574       };
38575     } catch (...) {
38576       {
38577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38578       };
38579     }
38580   }
38581
38582   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38583   return jresult;
38584 }
38585
38586
38587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38588   void * jresult ;
38589   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38590   Dali::RenderTaskList result;
38591
38592   arg1 = (Dali::Stage *)jarg1;
38593   {
38594     try {
38595       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38596     } catch (std::out_of_range& e) {
38597       {
38598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38599       };
38600     } catch (std::exception& e) {
38601       {
38602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38603       };
38604     } catch (Dali::DaliException e) {
38605       {
38606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38607       };
38608     } catch (...) {
38609       {
38610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38611       };
38612     }
38613   }
38614
38615   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38616   return jresult;
38617 }
38618
38619
38620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38621   unsigned int jresult ;
38622   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38623   unsigned int result;
38624
38625   arg1 = (Dali::Stage *)jarg1;
38626   {
38627     try {
38628       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38629     } catch (std::out_of_range& e) {
38630       {
38631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38632       };
38633     } catch (std::exception& e) {
38634       {
38635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38636       };
38637     } catch (Dali::DaliException e) {
38638       {
38639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38640       };
38641     } catch (...) {
38642       {
38643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38644       };
38645     }
38646   }
38647
38648   jresult = result;
38649   return jresult;
38650 }
38651
38652
38653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38654   void * jresult ;
38655   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38656   unsigned int arg2 ;
38657   Dali::Layer result;
38658
38659   arg1 = (Dali::Stage *)jarg1;
38660   arg2 = (unsigned int)jarg2;
38661   {
38662     try {
38663       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38664     } catch (std::out_of_range& e) {
38665       {
38666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38667       };
38668     } catch (std::exception& e) {
38669       {
38670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38671       };
38672     } catch (Dali::DaliException e) {
38673       {
38674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38675       };
38676     } catch (...) {
38677       {
38678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38679       };
38680     }
38681   }
38682
38683   jresult = new Dali::Layer((const Dali::Layer &)result);
38684   return jresult;
38685 }
38686
38687
38688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38689   void * jresult ;
38690   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38691   Dali::Layer result;
38692
38693   arg1 = (Dali::Stage *)jarg1;
38694   {
38695     try {
38696       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38697     } catch (std::out_of_range& e) {
38698       {
38699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38700       };
38701     } catch (std::exception& e) {
38702       {
38703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38704       };
38705     } catch (Dali::DaliException e) {
38706       {
38707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38708       };
38709     } catch (...) {
38710       {
38711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38712       };
38713     }
38714   }
38715
38716   jresult = new Dali::Layer((const Dali::Layer &)result);
38717   return jresult;
38718 }
38719
38720
38721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38722   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38723   Dali::Vector4 arg2 ;
38724   Dali::Vector4 *argp2 ;
38725
38726   arg1 = (Dali::Stage *)jarg1;
38727   argp2 = (Dali::Vector4 *)jarg2;
38728   if (!argp2) {
38729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38730     return ;
38731   }
38732   arg2 = *argp2;
38733   {
38734     try {
38735       (arg1)->SetBackgroundColor(arg2);
38736     } catch (std::out_of_range& e) {
38737       {
38738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38739       };
38740     } catch (std::exception& e) {
38741       {
38742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38743       };
38744     } catch (Dali::DaliException e) {
38745       {
38746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38747       };
38748     } catch (...) {
38749       {
38750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38751       };
38752     }
38753   }
38754
38755 }
38756
38757
38758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38759   void * jresult ;
38760   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38761   Dali::Vector4 result;
38762
38763   arg1 = (Dali::Stage *)jarg1;
38764   {
38765     try {
38766       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38767     } catch (std::out_of_range& e) {
38768       {
38769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38770       };
38771     } catch (std::exception& e) {
38772       {
38773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38774       };
38775     } catch (Dali::DaliException e) {
38776       {
38777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38778       };
38779     } catch (...) {
38780       {
38781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38782       };
38783     }
38784   }
38785
38786   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38787   return jresult;
38788 }
38789
38790
38791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38792   void * jresult ;
38793   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38794   Dali::Vector2 result;
38795
38796   arg1 = (Dali::Stage *)jarg1;
38797   {
38798     try {
38799       result = ((Dali::Stage const *)arg1)->GetDpi();
38800     } catch (std::out_of_range& e) {
38801       {
38802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38803       };
38804     } catch (std::exception& e) {
38805       {
38806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38807       };
38808     } catch (Dali::DaliException e) {
38809       {
38810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38811       };
38812     } catch (...) {
38813       {
38814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38815       };
38816     }
38817   }
38818
38819   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38820   return jresult;
38821 }
38822
38823
38824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38825   void * jresult ;
38826   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38827   Dali::ObjectRegistry result;
38828
38829   arg1 = (Dali::Stage *)jarg1;
38830   {
38831     try {
38832       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38833     } catch (std::out_of_range& e) {
38834       {
38835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38836       };
38837     } catch (std::exception& e) {
38838       {
38839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38840       };
38841     } catch (Dali::DaliException e) {
38842       {
38843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38844       };
38845     } catch (...) {
38846       {
38847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38848       };
38849     }
38850   }
38851
38852   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38853   return jresult;
38854 }
38855
38856
38857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38858   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38859   float arg2 ;
38860
38861   arg1 = (Dali::Stage *)jarg1;
38862   arg2 = (float)jarg2;
38863   {
38864     try {
38865       (arg1)->KeepRendering(arg2);
38866     } catch (std::out_of_range& e) {
38867       {
38868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38869       };
38870     } catch (std::exception& e) {
38871       {
38872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38873       };
38874     } catch (Dali::DaliException e) {
38875       {
38876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38877       };
38878     } catch (...) {
38879       {
38880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38881       };
38882     }
38883   }
38884
38885 }
38886
38887
38888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38889   void * jresult ;
38890   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38891   Dali::Stage::KeyEventSignalType *result = 0 ;
38892
38893   arg1 = (Dali::Stage *)jarg1;
38894   {
38895     try {
38896       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38897     } catch (std::out_of_range& e) {
38898       {
38899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38900       };
38901     } catch (std::exception& e) {
38902       {
38903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38904       };
38905     } catch (Dali::DaliException e) {
38906       {
38907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38908       };
38909     } catch (...) {
38910       {
38911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38912       };
38913     }
38914   }
38915
38916   jresult = (void *)result;
38917   return jresult;
38918 }
38919
38920
38921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38922   void * jresult ;
38923   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38924   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38925
38926   arg1 = (Dali::Stage *)jarg1;
38927   {
38928     try {
38929       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38930     } catch (std::out_of_range& e) {
38931       {
38932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38933       };
38934     } catch (std::exception& e) {
38935       {
38936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38937       };
38938     } catch (Dali::DaliException e) {
38939       {
38940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38941       };
38942     } catch (...) {
38943       {
38944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38945       };
38946     }
38947   }
38948
38949   jresult = (void *)result;
38950   return jresult;
38951 }
38952
38953
38954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38955   void * jresult ;
38956   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38957   Dali::Stage::TouchSignalType *result = 0 ;
38958
38959   arg1 = (Dali::Stage *)jarg1;
38960   {
38961     try {
38962       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38963     } catch (std::out_of_range& e) {
38964       {
38965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38966       };
38967     } catch (std::exception& e) {
38968       {
38969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38970       };
38971     } catch (Dali::DaliException e) {
38972       {
38973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38974       };
38975     } catch (...) {
38976       {
38977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38978       };
38979     }
38980   }
38981
38982   jresult = (void *)result;
38983   return jresult;
38984 }
38985
38986
38987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38988   void * jresult ;
38989   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38990   Dali::Stage::WheelEventSignalType *result = 0 ;
38991
38992   arg1 = (Dali::Stage *)jarg1;
38993   {
38994     try {
38995       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38996     } catch (std::out_of_range& e) {
38997       {
38998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38999       };
39000     } catch (std::exception& e) {
39001       {
39002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39003       };
39004     } catch (Dali::DaliException e) {
39005       {
39006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39007       };
39008     } catch (...) {
39009       {
39010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39011       };
39012     }
39013   }
39014
39015   jresult = (void *)result;
39016   return jresult;
39017 }
39018
39019
39020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39021   void * jresult ;
39022   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39023   Dali::Stage::ContextStatusSignal *result = 0 ;
39024
39025   arg1 = (Dali::Stage *)jarg1;
39026   {
39027     try {
39028       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39029     } catch (std::out_of_range& e) {
39030       {
39031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39032       };
39033     } catch (std::exception& e) {
39034       {
39035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39036       };
39037     } catch (Dali::DaliException e) {
39038       {
39039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39040       };
39041     } catch (...) {
39042       {
39043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39044       };
39045     }
39046   }
39047
39048   jresult = (void *)result;
39049   return jresult;
39050 }
39051
39052
39053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39054   void * jresult ;
39055   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39056   Dali::Stage::ContextStatusSignal *result = 0 ;
39057
39058   arg1 = (Dali::Stage *)jarg1;
39059   {
39060     try {
39061       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39062     } catch (std::out_of_range& e) {
39063       {
39064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39065       };
39066     } catch (std::exception& e) {
39067       {
39068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39069       };
39070     } catch (Dali::DaliException e) {
39071       {
39072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39073       };
39074     } catch (...) {
39075       {
39076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39077       };
39078     }
39079   }
39080
39081   jresult = (void *)result;
39082   return jresult;
39083 }
39084
39085
39086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39087   void * jresult ;
39088   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39089   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39090
39091   arg1 = (Dali::Stage *)jarg1;
39092   {
39093     try {
39094       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39095     } catch (std::out_of_range& e) {
39096       {
39097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39098       };
39099     } catch (std::exception& e) {
39100       {
39101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39102       };
39103     } catch (Dali::DaliException e) {
39104       {
39105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39106       };
39107     } catch (...) {
39108       {
39109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39110       };
39111     }
39112   }
39113
39114   jresult = (void *)result;
39115   return jresult;
39116 }
39117
39118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39119   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39120   Dali::DevelStage::Rendering arg2 ;
39121
39122   arg1 = (Dali::Stage *)jarg1;
39123   arg2 = (Dali::DevelStage::Rendering)jarg2;
39124   {
39125     try {
39126       DevelStage::SetRenderingBehavior(*arg1,arg2);
39127     } catch (std::out_of_range& e) {
39128       {
39129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39130       };
39131     } catch (std::exception& e) {
39132       {
39133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39134       };
39135     } catch (Dali::DaliException e) {
39136       {
39137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39138       };
39139     } catch (...) {
39140       {
39141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39142       };
39143     }
39144   }
39145
39146 }
39147
39148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39149
39150   int jresult ;
39151   int result ;
39152   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39153
39154   arg1 = (Dali::Stage *)jarg1;
39155   {
39156     try {
39157       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39158     } catch (std::out_of_range& e) {
39159       {
39160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39161       };
39162     } catch (std::exception& e) {
39163       {
39164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39165       };
39166     } catch (Dali::DaliException e) {
39167       {
39168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39169       };
39170     } catch (...) {
39171       {
39172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39173       };
39174     }
39175   }
39176
39177   jresult = result;
39178   return jresult;
39179 }
39180
39181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39182   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39183
39184   arg1 = (Dali::RelayoutContainer *)jarg1;
39185   {
39186     try {
39187       delete arg1;
39188     } catch (std::out_of_range& e) {
39189       {
39190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39191       };
39192     } catch (std::exception& e) {
39193       {
39194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39195       };
39196     } catch (Dali::DaliException e) {
39197       {
39198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39199       };
39200     } catch (...) {
39201       {
39202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39203       };
39204     }
39205   }
39206
39207 }
39208
39209
39210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39211   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39212   Dali::Actor *arg2 = 0 ;
39213   Dali::Vector2 *arg3 = 0 ;
39214
39215   arg1 = (Dali::RelayoutContainer *)jarg1;
39216   arg2 = (Dali::Actor *)jarg2;
39217   if (!arg2) {
39218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39219     return ;
39220   }
39221   arg3 = (Dali::Vector2 *)jarg3;
39222   if (!arg3) {
39223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39224     return ;
39225   }
39226   {
39227     try {
39228       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39229     } catch (std::out_of_range& e) {
39230       {
39231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39232       };
39233     } catch (std::exception& e) {
39234       {
39235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39236       };
39237     } catch (Dali::DaliException e) {
39238       {
39239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39240       };
39241     } catch (...) {
39242       {
39243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39244       };
39245     }
39246   }
39247
39248 }
39249
39250
39251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39252   void * jresult ;
39253   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39254   Dali::CustomActor result;
39255
39256   arg1 = (Dali::CustomActorImpl *)jarg1;
39257   {
39258     try {
39259       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39260     } catch (std::out_of_range& e) {
39261       {
39262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39263       };
39264     } catch (std::exception& e) {
39265       {
39266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39267       };
39268     } catch (Dali::DaliException e) {
39269       {
39270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39271       };
39272     } catch (...) {
39273       {
39274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39275       };
39276     }
39277   }
39278
39279   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39280   return jresult;
39281 }
39282
39283
39284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39285   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39286   int arg2 ;
39287
39288   arg1 = (Dali::CustomActorImpl *)jarg1;
39289   arg2 = (int)jarg2;
39290   {
39291     try {
39292       (arg1)->OnStageConnection(arg2);
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 void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39316   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39317
39318   arg1 = (Dali::CustomActorImpl *)jarg1;
39319   {
39320     try {
39321       (arg1)->OnStageDisconnection();
39322     } catch (std::out_of_range& e) {
39323       {
39324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39325       };
39326     } catch (std::exception& e) {
39327       {
39328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39329       };
39330     } catch (Dali::DaliException e) {
39331       {
39332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39333       };
39334     } catch (...) {
39335       {
39336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39337       };
39338     }
39339   }
39340
39341 }
39342
39343
39344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39345   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39346   Dali::Actor *arg2 = 0 ;
39347
39348   arg1 = (Dali::CustomActorImpl *)jarg1;
39349   arg2 = (Dali::Actor *)jarg2;
39350   if (!arg2) {
39351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39352     return ;
39353   }
39354   {
39355     try {
39356       (arg1)->OnChildAdd(*arg2);
39357     } catch (std::out_of_range& e) {
39358       {
39359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39360       };
39361     } catch (std::exception& e) {
39362       {
39363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39364       };
39365     } catch (Dali::DaliException e) {
39366       {
39367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39368       };
39369     } catch (...) {
39370       {
39371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39372       };
39373     }
39374   }
39375
39376 }
39377
39378
39379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39380   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39381   Dali::Actor *arg2 = 0 ;
39382
39383   arg1 = (Dali::CustomActorImpl *)jarg1;
39384   arg2 = (Dali::Actor *)jarg2;
39385   if (!arg2) {
39386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39387     return ;
39388   }
39389   {
39390     try {
39391       (arg1)->OnChildRemove(*arg2);
39392     } catch (std::out_of_range& e) {
39393       {
39394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39395       };
39396     } catch (std::exception& e) {
39397       {
39398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39399       };
39400     } catch (Dali::DaliException e) {
39401       {
39402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39403       };
39404     } catch (...) {
39405       {
39406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39407       };
39408     }
39409   }
39410
39411 }
39412
39413
39414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39415   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39416   Dali::Property::Index arg2 ;
39417   Dali::Property::Value arg3 ;
39418   Dali::Property::Value *argp3 ;
39419
39420   arg1 = (Dali::CustomActorImpl *)jarg1;
39421   arg2 = (Dali::Property::Index)jarg2;
39422   argp3 = (Dali::Property::Value *)jarg3;
39423   if (!argp3) {
39424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39425     return ;
39426   }
39427   arg3 = *argp3;
39428   {
39429     try {
39430       (arg1)->OnPropertySet(arg2,arg3);
39431     } catch (std::out_of_range& e) {
39432       {
39433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39434       };
39435     } catch (std::exception& e) {
39436       {
39437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39438       };
39439     } catch (Dali::DaliException e) {
39440       {
39441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39442       };
39443     } catch (...) {
39444       {
39445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39446       };
39447     }
39448   }
39449
39450 }
39451
39452
39453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39454   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39455   Dali::Vector3 *arg2 = 0 ;
39456
39457   arg1 = (Dali::CustomActorImpl *)jarg1;
39458   arg2 = (Dali::Vector3 *)jarg2;
39459   if (!arg2) {
39460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39461     return ;
39462   }
39463   {
39464     try {
39465       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39466     } catch (std::out_of_range& e) {
39467       {
39468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39469       };
39470     } catch (std::exception& e) {
39471       {
39472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39473       };
39474     } catch (Dali::DaliException e) {
39475       {
39476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39477       };
39478     } catch (...) {
39479       {
39480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39481       };
39482     }
39483   }
39484
39485 }
39486
39487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39488   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39489   Dali::Animation *arg2 = 0 ;
39490   Dali::Vector3 *arg3 = 0 ;
39491
39492   arg1 = (Dali::CustomActorImpl *)jarg1;
39493   arg2 = (Dali::Animation *)jarg2;
39494   if (!arg2) {
39495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39496     return ;
39497   }
39498   arg3 = (Dali::Vector3 *)jarg3;
39499   if (!arg3) {
39500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39501     return ;
39502   }
39503   {
39504     try {
39505       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39506     } catch (std::out_of_range& e) {
39507       {
39508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39509       };
39510     } catch (std::exception& e) {
39511       {
39512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39513       };
39514     } catch (Dali::DaliException e) {
39515       {
39516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39517       };
39518     } catch (...) {
39519       {
39520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39521       };
39522     }
39523   }
39524
39525 }
39526
39527
39528 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39529   unsigned int jresult ;
39530   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39531   Dali::TouchEvent *arg2 = 0 ;
39532   bool result;
39533
39534   arg1 = (Dali::CustomActorImpl *)jarg1;
39535   arg2 = (Dali::TouchEvent *)jarg2;
39536   if (!arg2) {
39537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39538     return 0;
39539   }
39540   {
39541     try {
39542       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39543     } catch (std::out_of_range& e) {
39544       {
39545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39546       };
39547     } catch (std::exception& e) {
39548       {
39549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39550       };
39551     } catch (Dali::DaliException e) {
39552       {
39553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39554       };
39555     } catch (...) {
39556       {
39557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39558       };
39559     }
39560   }
39561
39562   jresult = result;
39563   return jresult;
39564 }
39565
39566
39567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39568   unsigned int jresult ;
39569   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39570   Dali::HoverEvent *arg2 = 0 ;
39571   bool result;
39572
39573   arg1 = (Dali::CustomActorImpl *)jarg1;
39574   arg2 = (Dali::HoverEvent *)jarg2;
39575   if (!arg2) {
39576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39577     return 0;
39578   }
39579   {
39580     try {
39581       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39582     } catch (std::out_of_range& e) {
39583       {
39584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39585       };
39586     } catch (std::exception& e) {
39587       {
39588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39589       };
39590     } catch (Dali::DaliException e) {
39591       {
39592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39593       };
39594     } catch (...) {
39595       {
39596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39597       };
39598     }
39599   }
39600
39601   jresult = result;
39602   return jresult;
39603 }
39604
39605
39606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39607   unsigned int jresult ;
39608   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39609   Dali::KeyEvent *arg2 = 0 ;
39610   bool result;
39611
39612   arg1 = (Dali::CustomActorImpl *)jarg1;
39613   arg2 = (Dali::KeyEvent *)jarg2;
39614   if (!arg2) {
39615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39616     return 0;
39617   }
39618   {
39619     try {
39620       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39621     } catch (std::out_of_range& e) {
39622       {
39623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39624       };
39625     } catch (std::exception& e) {
39626       {
39627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39628       };
39629     } catch (Dali::DaliException e) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39632       };
39633     } catch (...) {
39634       {
39635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39636       };
39637     }
39638   }
39639
39640   jresult = result;
39641   return jresult;
39642 }
39643
39644
39645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39646   unsigned int jresult ;
39647   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39648   Dali::WheelEvent *arg2 = 0 ;
39649   bool result;
39650
39651   arg1 = (Dali::CustomActorImpl *)jarg1;
39652   arg2 = (Dali::WheelEvent *)jarg2;
39653   if (!arg2) {
39654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39655     return 0;
39656   }
39657   {
39658     try {
39659       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39660     } catch (std::out_of_range& e) {
39661       {
39662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39663       };
39664     } catch (std::exception& e) {
39665       {
39666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39667       };
39668     } catch (Dali::DaliException e) {
39669       {
39670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39671       };
39672     } catch (...) {
39673       {
39674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39675       };
39676     }
39677   }
39678
39679   jresult = result;
39680   return jresult;
39681 }
39682
39683
39684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39685   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39686   Dali::Vector2 *arg2 = 0 ;
39687   Dali::RelayoutContainer *arg3 = 0 ;
39688
39689   arg1 = (Dali::CustomActorImpl *)jarg1;
39690   arg2 = (Dali::Vector2 *)jarg2;
39691   if (!arg2) {
39692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39693     return ;
39694   }
39695   arg3 = (Dali::RelayoutContainer *)jarg3;
39696   if (!arg3) {
39697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39698     return ;
39699   }
39700   {
39701     try {
39702       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39703     } catch (std::out_of_range& e) {
39704       {
39705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39706       };
39707     } catch (std::exception& e) {
39708       {
39709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39710       };
39711     } catch (Dali::DaliException e) {
39712       {
39713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39714       };
39715     } catch (...) {
39716       {
39717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39718       };
39719     }
39720   }
39721
39722 }
39723
39724
39725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39726   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39727   Dali::ResizePolicy::Type arg2 ;
39728   Dali::Dimension::Type arg3 ;
39729
39730   arg1 = (Dali::CustomActorImpl *)jarg1;
39731   arg2 = (Dali::ResizePolicy::Type)jarg2;
39732   arg3 = (Dali::Dimension::Type)jarg3;
39733   {
39734     try {
39735       (arg1)->OnSetResizePolicy(arg2,arg3);
39736     } catch (std::out_of_range& e) {
39737       {
39738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39739       };
39740     } catch (std::exception& e) {
39741       {
39742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39743       };
39744     } catch (Dali::DaliException e) {
39745       {
39746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39747       };
39748     } catch (...) {
39749       {
39750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39751       };
39752     }
39753   }
39754
39755 }
39756
39757
39758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39759   void * jresult ;
39760   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39761   Dali::Vector3 result;
39762
39763   arg1 = (Dali::CustomActorImpl *)jarg1;
39764   {
39765     try {
39766       result = (arg1)->GetNaturalSize();
39767     } catch (std::out_of_range& e) {
39768       {
39769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39770       };
39771     } catch (std::exception& e) {
39772       {
39773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39774       };
39775     } catch (Dali::DaliException e) {
39776       {
39777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39778       };
39779     } catch (...) {
39780       {
39781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39782       };
39783     }
39784   }
39785
39786   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39787   return jresult;
39788 }
39789
39790
39791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39792   float jresult ;
39793   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39794   Dali::Actor *arg2 = 0 ;
39795   Dali::Dimension::Type arg3 ;
39796   float result;
39797
39798   arg1 = (Dali::CustomActorImpl *)jarg1;
39799   arg2 = (Dali::Actor *)jarg2;
39800   if (!arg2) {
39801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39802     return 0;
39803   }
39804   arg3 = (Dali::Dimension::Type)jarg3;
39805   {
39806     try {
39807       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39808     } catch (std::out_of_range& e) {
39809       {
39810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39811       };
39812     } catch (std::exception& e) {
39813       {
39814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39815       };
39816     } catch (Dali::DaliException e) {
39817       {
39818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39819       };
39820     } catch (...) {
39821       {
39822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39823       };
39824     }
39825   }
39826
39827   jresult = result;
39828   return jresult;
39829 }
39830
39831
39832 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39833   float jresult ;
39834   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39835   float arg2 ;
39836   float result;
39837
39838   arg1 = (Dali::CustomActorImpl *)jarg1;
39839   arg2 = (float)jarg2;
39840   {
39841     try {
39842       result = (float)(arg1)->GetHeightForWidth(arg2);
39843     } catch (std::out_of_range& e) {
39844       {
39845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39846       };
39847     } catch (std::exception& e) {
39848       {
39849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39850       };
39851     } catch (Dali::DaliException e) {
39852       {
39853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39854       };
39855     } catch (...) {
39856       {
39857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39858       };
39859     }
39860   }
39861
39862   jresult = result;
39863   return jresult;
39864 }
39865
39866
39867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39868   float jresult ;
39869   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39870   float arg2 ;
39871   float result;
39872
39873   arg1 = (Dali::CustomActorImpl *)jarg1;
39874   arg2 = (float)jarg2;
39875   {
39876     try {
39877       result = (float)(arg1)->GetWidthForHeight(arg2);
39878     } catch (std::out_of_range& e) {
39879       {
39880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39881       };
39882     } catch (std::exception& e) {
39883       {
39884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39885       };
39886     } catch (Dali::DaliException e) {
39887       {
39888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39889       };
39890     } catch (...) {
39891       {
39892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39893       };
39894     }
39895   }
39896
39897   jresult = result;
39898   return jresult;
39899 }
39900
39901
39902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39903   unsigned int jresult ;
39904   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39905   Dali::Dimension::Type arg2 ;
39906   bool result;
39907
39908   arg1 = (Dali::CustomActorImpl *)jarg1;
39909   arg2 = (Dali::Dimension::Type)jarg2;
39910   {
39911     try {
39912       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39913     } catch (std::out_of_range& e) {
39914       {
39915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39916       };
39917     } catch (std::exception& e) {
39918       {
39919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39920       };
39921     } catch (Dali::DaliException e) {
39922       {
39923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39924       };
39925     } catch (...) {
39926       {
39927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39928       };
39929     }
39930   }
39931
39932   jresult = result;
39933   return jresult;
39934 }
39935
39936
39937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39938   unsigned int jresult ;
39939   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39940   bool result;
39941
39942   arg1 = (Dali::CustomActorImpl *)jarg1;
39943   {
39944     try {
39945       result = (bool)(arg1)->RelayoutDependentOnChildren();
39946     } catch (std::out_of_range& e) {
39947       {
39948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39949       };
39950     } catch (std::exception& e) {
39951       {
39952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39953       };
39954     } catch (Dali::DaliException e) {
39955       {
39956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39957       };
39958     } catch (...) {
39959       {
39960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39961       };
39962     }
39963   }
39964
39965   jresult = result;
39966   return jresult;
39967 }
39968
39969
39970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39971   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39972   Dali::Dimension::Type arg2 ;
39973
39974   arg1 = (Dali::CustomActorImpl *)jarg1;
39975   arg2 = (Dali::Dimension::Type)jarg2;
39976   {
39977     try {
39978       (arg1)->OnCalculateRelayoutSize(arg2);
39979     } catch (std::out_of_range& e) {
39980       {
39981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39982       };
39983     } catch (std::exception& e) {
39984       {
39985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39986       };
39987     } catch (Dali::DaliException e) {
39988       {
39989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39990       };
39991     } catch (...) {
39992       {
39993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39994       };
39995     }
39996   }
39997
39998 }
39999
40000
40001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40002   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40003   float arg2 ;
40004   Dali::Dimension::Type arg3 ;
40005
40006   arg1 = (Dali::CustomActorImpl *)jarg1;
40007   arg2 = (float)jarg2;
40008   arg3 = (Dali::Dimension::Type)jarg3;
40009   {
40010     try {
40011       (arg1)->OnLayoutNegotiated(arg2,arg3);
40012     } catch (std::out_of_range& e) {
40013       {
40014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40015       };
40016     } catch (std::exception& e) {
40017       {
40018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40019       };
40020     } catch (Dali::DaliException e) {
40021       {
40022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40023       };
40024     } catch (...) {
40025       {
40026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40027       };
40028     }
40029   }
40030
40031 }
40032
40033
40034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40035   unsigned int jresult ;
40036   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40037   bool result;
40038
40039   arg1 = (Dali::CustomActorImpl *)jarg1;
40040   {
40041     try {
40042       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40043     } catch (std::out_of_range& e) {
40044       {
40045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40046       };
40047     } catch (std::exception& e) {
40048       {
40049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40050       };
40051     } catch (Dali::DaliException e) {
40052       {
40053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40054       };
40055     } catch (...) {
40056       {
40057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40058       };
40059     }
40060   }
40061
40062   jresult = result;
40063   return jresult;
40064 }
40065
40066
40067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40068   unsigned int jresult ;
40069   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40070   bool result;
40071
40072   arg1 = (Dali::CustomActorImpl *)jarg1;
40073   {
40074     try {
40075       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40076     } catch (std::out_of_range& e) {
40077       {
40078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40079       };
40080     } catch (std::exception& e) {
40081       {
40082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40083       };
40084     } catch (Dali::DaliException e) {
40085       {
40086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40087       };
40088     } catch (...) {
40089       {
40090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40091       };
40092     }
40093   }
40094
40095   jresult = result;
40096   return jresult;
40097 }
40098
40099
40100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40101   unsigned int jresult ;
40102   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40103   bool result;
40104
40105   arg1 = (Dali::CustomActorImpl *)jarg1;
40106   {
40107     try {
40108       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40109     } catch (std::out_of_range& e) {
40110       {
40111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40112       };
40113     } catch (std::exception& e) {
40114       {
40115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40116       };
40117     } catch (Dali::DaliException e) {
40118       {
40119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40120       };
40121     } catch (...) {
40122       {
40123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40124       };
40125     }
40126   }
40127
40128   jresult = result;
40129   return jresult;
40130 }
40131
40132
40133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40134   unsigned int jresult ;
40135   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40136   bool result;
40137
40138   arg1 = (Dali::CustomActorImpl *)jarg1;
40139   {
40140     try {
40141       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40142     } catch (std::out_of_range& e) {
40143       {
40144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40145       };
40146     } catch (std::exception& e) {
40147       {
40148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40149       };
40150     } catch (Dali::DaliException e) {
40151       {
40152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40153       };
40154     } catch (...) {
40155       {
40156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40157       };
40158     }
40159   }
40160
40161   jresult = result;
40162   return jresult;
40163 }
40164
40165
40166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40167   void * jresult ;
40168   Dali::CustomActor *result = 0 ;
40169
40170   {
40171     try {
40172       result = (Dali::CustomActor *)new Dali::CustomActor();
40173     } catch (std::out_of_range& e) {
40174       {
40175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40176       };
40177     } catch (std::exception& e) {
40178       {
40179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40180       };
40181     } catch (Dali::DaliException e) {
40182       {
40183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40184       };
40185     } catch (...) {
40186       {
40187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40188       };
40189     }
40190   }
40191
40192   jresult = (void *)result;
40193   return jresult;
40194 }
40195
40196
40197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40198   void * jresult ;
40199   Dali::BaseHandle arg1 ;
40200   Dali::BaseHandle *argp1 ;
40201   Dali::CustomActor result;
40202
40203   argp1 = (Dali::BaseHandle *)jarg1;
40204   if (!argp1) {
40205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40206     return 0;
40207   }
40208   arg1 = *argp1;
40209   {
40210     try {
40211       result = Dali::CustomActor::DownCast(arg1);
40212     } catch (std::out_of_range& e) {
40213       {
40214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40215       };
40216     } catch (std::exception& e) {
40217       {
40218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40219       };
40220     } catch (Dali::DaliException e) {
40221       {
40222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40223       };
40224     } catch (...) {
40225       {
40226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40227       };
40228     }
40229   }
40230
40231   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40232   return jresult;
40233 }
40234
40235
40236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40237   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40238
40239   arg1 = (Dali::CustomActor *)jarg1;
40240   {
40241     try {
40242       delete arg1;
40243     } catch (std::out_of_range& e) {
40244       {
40245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40246       };
40247     } catch (std::exception& e) {
40248       {
40249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40250       };
40251     } catch (Dali::DaliException e) {
40252       {
40253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40254       };
40255     } catch (...) {
40256       {
40257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40258       };
40259     }
40260   }
40261
40262 }
40263
40264
40265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40266   void * jresult ;
40267   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40268   Dali::CustomActorImpl *result = 0 ;
40269
40270   arg1 = (Dali::CustomActor *)jarg1;
40271   {
40272     try {
40273       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40274     } catch (std::out_of_range& e) {
40275       {
40276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40277       };
40278     } catch (std::exception& e) {
40279       {
40280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40281       };
40282     } catch (Dali::DaliException e) {
40283       {
40284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40285       };
40286     } catch (...) {
40287       {
40288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40289       };
40290     }
40291   }
40292
40293   jresult = (void *)result;
40294   return jresult;
40295 }
40296
40297
40298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40299   void * jresult ;
40300   Dali::CustomActorImpl *arg1 = 0 ;
40301   Dali::CustomActor *result = 0 ;
40302
40303   arg1 = (Dali::CustomActorImpl *)jarg1;
40304   if (!arg1) {
40305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40306     return 0;
40307   }
40308   {
40309     try {
40310       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40311     } catch (std::out_of_range& e) {
40312       {
40313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40314       };
40315     } catch (std::exception& e) {
40316       {
40317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40318       };
40319     } catch (Dali::DaliException e) {
40320       {
40321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40322       };
40323     } catch (...) {
40324       {
40325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40326       };
40327     }
40328   }
40329
40330   jresult = (void *)result;
40331   return jresult;
40332 }
40333
40334
40335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40336   void * jresult ;
40337   Dali::CustomActor *arg1 = 0 ;
40338   Dali::CustomActor *result = 0 ;
40339
40340   arg1 = (Dali::CustomActor *)jarg1;
40341   if (!arg1) {
40342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40343     return 0;
40344   }
40345   {
40346     try {
40347       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40348     } catch (std::out_of_range& e) {
40349       {
40350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40351       };
40352     } catch (std::exception& e) {
40353       {
40354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40355       };
40356     } catch (Dali::DaliException e) {
40357       {
40358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40359       };
40360     } catch (...) {
40361       {
40362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40363       };
40364     }
40365   }
40366
40367   jresult = (void *)result;
40368   return jresult;
40369 }
40370
40371
40372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40373   void * jresult ;
40374   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40375   Dali::CustomActor *arg2 = 0 ;
40376   Dali::CustomActor *result = 0 ;
40377
40378   arg1 = (Dali::CustomActor *)jarg1;
40379   arg2 = (Dali::CustomActor *)jarg2;
40380   if (!arg2) {
40381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40382     return 0;
40383   }
40384   {
40385     try {
40386       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40387     } catch (std::out_of_range& e) {
40388       {
40389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40390       };
40391     } catch (std::exception& e) {
40392       {
40393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40394       };
40395     } catch (Dali::DaliException e) {
40396       {
40397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40398       };
40399     } catch (...) {
40400       {
40401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40402       };
40403     }
40404   }
40405
40406   jresult = (void *)result;
40407   return jresult;
40408 }
40409
40410
40411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40412   int jresult ;
40413   int result;
40414
40415   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40416   jresult = (int)result;
40417   return jresult;
40418 }
40419
40420
40421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40422   int jresult ;
40423   int result;
40424
40425   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40426   jresult = (int)result;
40427   return jresult;
40428 }
40429
40430
40431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40432   int jresult ;
40433   int result;
40434
40435   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40436   jresult = (int)result;
40437   return jresult;
40438 }
40439
40440
40441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40442   int jresult ;
40443   int result;
40444
40445   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40446   jresult = (int)result;
40447   return jresult;
40448 }
40449
40450
40451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40452   int jresult ;
40453   int result;
40454
40455   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40456   jresult = (int)result;
40457   return jresult;
40458 }
40459
40460
40461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40462   int jresult ;
40463   int result;
40464
40465   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40466   jresult = (int)result;
40467   return jresult;
40468 }
40469
40470
40471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40472   int jresult ;
40473   int result;
40474
40475   result = (int)Dali::PanGestureDetector::Property::PANNING;
40476   jresult = (int)result;
40477   return jresult;
40478 }
40479
40480
40481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40482   void * jresult ;
40483   Dali::PanGestureDetector::Property *result = 0 ;
40484
40485   {
40486     try {
40487       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40488     } catch (std::out_of_range& e) {
40489       {
40490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40491       };
40492     } catch (std::exception& e) {
40493       {
40494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40495       };
40496     } catch (Dali::DaliException e) {
40497       {
40498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40499       };
40500     } catch (...) {
40501       {
40502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40503       };
40504     }
40505   }
40506
40507   jresult = (void *)result;
40508   return jresult;
40509 }
40510
40511
40512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40513   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40514
40515   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40516   {
40517     try {
40518       delete arg1;
40519     } catch (std::out_of_range& e) {
40520       {
40521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40522       };
40523     } catch (std::exception& e) {
40524       {
40525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40526       };
40527     } catch (Dali::DaliException e) {
40528       {
40529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40530       };
40531     } catch (...) {
40532       {
40533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40534       };
40535     }
40536   }
40537
40538 }
40539
40540
40541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40542   void * jresult ;
40543   Dali::Radian *result = 0 ;
40544
40545   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40546   jresult = (void *)result;
40547   return jresult;
40548 }
40549
40550
40551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40552   void * jresult ;
40553   Dali::Radian *result = 0 ;
40554
40555   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40556   jresult = (void *)result;
40557   return jresult;
40558 }
40559
40560
40561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40562   void * jresult ;
40563   Dali::Radian *result = 0 ;
40564
40565   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40566   jresult = (void *)result;
40567   return jresult;
40568 }
40569
40570
40571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40572   void * jresult ;
40573   Dali::Radian *result = 0 ;
40574
40575   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40576   jresult = (void *)result;
40577   return jresult;
40578 }
40579
40580
40581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40582   void * jresult ;
40583   Dali::Radian *result = 0 ;
40584
40585   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40586   jresult = (void *)result;
40587   return jresult;
40588 }
40589
40590
40591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40592   void * jresult ;
40593   Dali::Radian *result = 0 ;
40594
40595   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40596   jresult = (void *)result;
40597   return jresult;
40598 }
40599
40600
40601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40602   void * jresult ;
40603   Dali::Radian *result = 0 ;
40604
40605   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40606   jresult = (void *)result;
40607   return jresult;
40608 }
40609
40610
40611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40612   void * jresult ;
40613   Dali::PanGestureDetector *result = 0 ;
40614
40615   {
40616     try {
40617       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40618     } catch (std::out_of_range& e) {
40619       {
40620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40621       };
40622     } catch (std::exception& e) {
40623       {
40624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40625       };
40626     } catch (Dali::DaliException e) {
40627       {
40628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40629       };
40630     } catch (...) {
40631       {
40632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40633       };
40634     }
40635   }
40636
40637   jresult = (void *)result;
40638   return jresult;
40639 }
40640
40641
40642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40643   void * jresult ;
40644   Dali::PanGestureDetector result;
40645
40646   {
40647     try {
40648       result = Dali::PanGestureDetector::New();
40649     } catch (std::out_of_range& e) {
40650       {
40651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40652       };
40653     } catch (std::exception& e) {
40654       {
40655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40656       };
40657     } catch (Dali::DaliException e) {
40658       {
40659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40660       };
40661     } catch (...) {
40662       {
40663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40664       };
40665     }
40666   }
40667
40668   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40669   return jresult;
40670 }
40671
40672
40673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40674   void * jresult ;
40675   Dali::BaseHandle arg1 ;
40676   Dali::BaseHandle *argp1 ;
40677   Dali::PanGestureDetector result;
40678
40679   argp1 = (Dali::BaseHandle *)jarg1;
40680   if (!argp1) {
40681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40682     return 0;
40683   }
40684   arg1 = *argp1;
40685   {
40686     try {
40687       result = Dali::PanGestureDetector::DownCast(arg1);
40688     } catch (std::out_of_range& e) {
40689       {
40690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40691       };
40692     } catch (std::exception& e) {
40693       {
40694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40695       };
40696     } catch (Dali::DaliException e) {
40697       {
40698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40699       };
40700     } catch (...) {
40701       {
40702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40703       };
40704     }
40705   }
40706
40707   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40708   return jresult;
40709 }
40710
40711
40712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40713   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40714
40715   arg1 = (Dali::PanGestureDetector *)jarg1;
40716   {
40717     try {
40718       delete arg1;
40719     } catch (std::out_of_range& e) {
40720       {
40721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40722       };
40723     } catch (std::exception& e) {
40724       {
40725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40726       };
40727     } catch (Dali::DaliException e) {
40728       {
40729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40730       };
40731     } catch (...) {
40732       {
40733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40734       };
40735     }
40736   }
40737
40738 }
40739
40740
40741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40742   void * jresult ;
40743   Dali::PanGestureDetector *arg1 = 0 ;
40744   Dali::PanGestureDetector *result = 0 ;
40745
40746   arg1 = (Dali::PanGestureDetector *)jarg1;
40747   if (!arg1) {
40748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40749     return 0;
40750   }
40751   {
40752     try {
40753       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40754     } catch (std::out_of_range& e) {
40755       {
40756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40757       };
40758     } catch (std::exception& e) {
40759       {
40760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40761       };
40762     } catch (Dali::DaliException e) {
40763       {
40764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40765       };
40766     } catch (...) {
40767       {
40768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40769       };
40770     }
40771   }
40772
40773   jresult = (void *)result;
40774   return jresult;
40775 }
40776
40777
40778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40779   void * jresult ;
40780   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40781   Dali::PanGestureDetector *arg2 = 0 ;
40782   Dali::PanGestureDetector *result = 0 ;
40783
40784   arg1 = (Dali::PanGestureDetector *)jarg1;
40785   arg2 = (Dali::PanGestureDetector *)jarg2;
40786   if (!arg2) {
40787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40788     return 0;
40789   }
40790   {
40791     try {
40792       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40793     } catch (std::out_of_range& e) {
40794       {
40795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40796       };
40797     } catch (std::exception& e) {
40798       {
40799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40800       };
40801     } catch (Dali::DaliException e) {
40802       {
40803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40804       };
40805     } catch (...) {
40806       {
40807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40808       };
40809     }
40810   }
40811
40812   jresult = (void *)result;
40813   return jresult;
40814 }
40815
40816
40817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40818   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40819   unsigned int arg2 ;
40820
40821   arg1 = (Dali::PanGestureDetector *)jarg1;
40822   arg2 = (unsigned int)jarg2;
40823   {
40824     try {
40825       (arg1)->SetMinimumTouchesRequired(arg2);
40826     } catch (std::out_of_range& e) {
40827       {
40828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40829       };
40830     } catch (std::exception& e) {
40831       {
40832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40833       };
40834     } catch (Dali::DaliException e) {
40835       {
40836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40837       };
40838     } catch (...) {
40839       {
40840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40841       };
40842     }
40843   }
40844
40845 }
40846
40847
40848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40849   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40850   unsigned int arg2 ;
40851
40852   arg1 = (Dali::PanGestureDetector *)jarg1;
40853   arg2 = (unsigned int)jarg2;
40854   {
40855     try {
40856       (arg1)->SetMaximumTouchesRequired(arg2);
40857     } catch (std::out_of_range& e) {
40858       {
40859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40860       };
40861     } catch (std::exception& e) {
40862       {
40863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40864       };
40865     } catch (Dali::DaliException e) {
40866       {
40867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40868       };
40869     } catch (...) {
40870       {
40871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40872       };
40873     }
40874   }
40875
40876 }
40877
40878
40879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40880   unsigned int jresult ;
40881   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40882   unsigned int result;
40883
40884   arg1 = (Dali::PanGestureDetector *)jarg1;
40885   {
40886     try {
40887       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40888     } catch (std::out_of_range& e) {
40889       {
40890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40891       };
40892     } catch (std::exception& e) {
40893       {
40894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40895       };
40896     } catch (Dali::DaliException e) {
40897       {
40898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40899       };
40900     } catch (...) {
40901       {
40902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40903       };
40904     }
40905   }
40906
40907   jresult = result;
40908   return jresult;
40909 }
40910
40911
40912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40913   unsigned int jresult ;
40914   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40915   unsigned int result;
40916
40917   arg1 = (Dali::PanGestureDetector *)jarg1;
40918   {
40919     try {
40920       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40921     } catch (std::out_of_range& e) {
40922       {
40923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40924       };
40925     } catch (std::exception& e) {
40926       {
40927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40928       };
40929     } catch (Dali::DaliException e) {
40930       {
40931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40932       };
40933     } catch (...) {
40934       {
40935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40936       };
40937     }
40938   }
40939
40940   jresult = result;
40941   return jresult;
40942 }
40943
40944
40945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40946   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40947   Dali::Radian arg2 ;
40948   Dali::Radian arg3 ;
40949   Dali::Radian *argp2 ;
40950   Dali::Radian *argp3 ;
40951
40952   arg1 = (Dali::PanGestureDetector *)jarg1;
40953   argp2 = (Dali::Radian *)jarg2;
40954   if (!argp2) {
40955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40956     return ;
40957   }
40958   arg2 = *argp2;
40959   argp3 = (Dali::Radian *)jarg3;
40960   if (!argp3) {
40961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40962     return ;
40963   }
40964   arg3 = *argp3;
40965   {
40966     try {
40967       (arg1)->AddAngle(arg2,arg3);
40968     } catch (std::out_of_range& e) {
40969       {
40970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40971       };
40972     } catch (std::exception& e) {
40973       {
40974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40975       };
40976     } catch (Dali::DaliException e) {
40977       {
40978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40979       };
40980     } catch (...) {
40981       {
40982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40983       };
40984     }
40985   }
40986
40987 }
40988
40989
40990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40991   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40992   Dali::Radian arg2 ;
40993   Dali::Radian *argp2 ;
40994
40995   arg1 = (Dali::PanGestureDetector *)jarg1;
40996   argp2 = (Dali::Radian *)jarg2;
40997   if (!argp2) {
40998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40999     return ;
41000   }
41001   arg2 = *argp2;
41002   {
41003     try {
41004       (arg1)->AddAngle(arg2);
41005     } catch (std::out_of_range& e) {
41006       {
41007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41008       };
41009     } catch (std::exception& e) {
41010       {
41011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41012       };
41013     } catch (Dali::DaliException e) {
41014       {
41015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41016       };
41017     } catch (...) {
41018       {
41019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41020       };
41021     }
41022   }
41023
41024 }
41025
41026
41027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41028   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41029   Dali::Radian arg2 ;
41030   Dali::Radian arg3 ;
41031   Dali::Radian *argp2 ;
41032   Dali::Radian *argp3 ;
41033
41034   arg1 = (Dali::PanGestureDetector *)jarg1;
41035   argp2 = (Dali::Radian *)jarg2;
41036   if (!argp2) {
41037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41038     return ;
41039   }
41040   arg2 = *argp2;
41041   argp3 = (Dali::Radian *)jarg3;
41042   if (!argp3) {
41043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41044     return ;
41045   }
41046   arg3 = *argp3;
41047   {
41048     try {
41049       (arg1)->AddDirection(arg2,arg3);
41050     } catch (std::out_of_range& e) {
41051       {
41052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41053       };
41054     } catch (std::exception& e) {
41055       {
41056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41057       };
41058     } catch (Dali::DaliException e) {
41059       {
41060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41061       };
41062     } catch (...) {
41063       {
41064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41065       };
41066     }
41067   }
41068
41069 }
41070
41071
41072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41073   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41074   Dali::Radian arg2 ;
41075   Dali::Radian *argp2 ;
41076
41077   arg1 = (Dali::PanGestureDetector *)jarg1;
41078   argp2 = (Dali::Radian *)jarg2;
41079   if (!argp2) {
41080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41081     return ;
41082   }
41083   arg2 = *argp2;
41084   {
41085     try {
41086       (arg1)->AddDirection(arg2);
41087     } catch (std::out_of_range& e) {
41088       {
41089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41090       };
41091     } catch (std::exception& e) {
41092       {
41093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41094       };
41095     } catch (Dali::DaliException e) {
41096       {
41097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41098       };
41099     } catch (...) {
41100       {
41101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41102       };
41103     }
41104   }
41105
41106 }
41107
41108
41109 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41110   unsigned long jresult ;
41111   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41112   size_t result;
41113
41114   arg1 = (Dali::PanGestureDetector *)jarg1;
41115   {
41116     try {
41117       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41118     } catch (std::out_of_range& e) {
41119       {
41120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41121       };
41122     } catch (std::exception& e) {
41123       {
41124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41125       };
41126     } catch (Dali::DaliException e) {
41127       {
41128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41129       };
41130     } catch (...) {
41131       {
41132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41133       };
41134     }
41135   }
41136
41137   jresult = (unsigned long)result;
41138   return jresult;
41139 }
41140
41141
41142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41143   void * jresult ;
41144   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41145   size_t arg2 ;
41146   Dali::PanGestureDetector::AngleThresholdPair result;
41147
41148   arg1 = (Dali::PanGestureDetector *)jarg1;
41149   arg2 = (size_t)jarg2;
41150   {
41151     try {
41152       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41153     } catch (std::out_of_range& e) {
41154       {
41155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41156       };
41157     } catch (std::exception& e) {
41158       {
41159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41160       };
41161     } catch (Dali::DaliException e) {
41162       {
41163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41164       };
41165     } catch (...) {
41166       {
41167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41168       };
41169     }
41170   }
41171
41172   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41173   return jresult;
41174 }
41175
41176
41177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41178   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41179
41180   arg1 = (Dali::PanGestureDetector *)jarg1;
41181   {
41182     try {
41183       (arg1)->ClearAngles();
41184     } catch (std::out_of_range& e) {
41185       {
41186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41187       };
41188     } catch (std::exception& e) {
41189       {
41190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41191       };
41192     } catch (Dali::DaliException e) {
41193       {
41194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41195       };
41196     } catch (...) {
41197       {
41198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41199       };
41200     }
41201   }
41202
41203 }
41204
41205
41206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41207   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41208   Dali::Radian arg2 ;
41209   Dali::Radian *argp2 ;
41210
41211   arg1 = (Dali::PanGestureDetector *)jarg1;
41212   argp2 = (Dali::Radian *)jarg2;
41213   if (!argp2) {
41214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41215     return ;
41216   }
41217   arg2 = *argp2;
41218   {
41219     try {
41220       (arg1)->RemoveAngle(arg2);
41221     } catch (std::out_of_range& e) {
41222       {
41223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41224       };
41225     } catch (std::exception& e) {
41226       {
41227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41228       };
41229     } catch (Dali::DaliException e) {
41230       {
41231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41232       };
41233     } catch (...) {
41234       {
41235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41236       };
41237     }
41238   }
41239
41240 }
41241
41242
41243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41244   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41245   Dali::Radian arg2 ;
41246   Dali::Radian *argp2 ;
41247
41248   arg1 = (Dali::PanGestureDetector *)jarg1;
41249   argp2 = (Dali::Radian *)jarg2;
41250   if (!argp2) {
41251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41252     return ;
41253   }
41254   arg2 = *argp2;
41255   {
41256     try {
41257       (arg1)->RemoveDirection(arg2);
41258     } catch (std::out_of_range& e) {
41259       {
41260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41261       };
41262     } catch (std::exception& e) {
41263       {
41264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41265       };
41266     } catch (Dali::DaliException e) {
41267       {
41268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41269       };
41270     } catch (...) {
41271       {
41272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41273       };
41274     }
41275   }
41276
41277 }
41278
41279
41280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41281   void * jresult ;
41282   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41283   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41284
41285   arg1 = (Dali::PanGestureDetector *)jarg1;
41286   {
41287     try {
41288       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41289     } catch (std::out_of_range& e) {
41290       {
41291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41292       };
41293     } catch (std::exception& e) {
41294       {
41295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41296       };
41297     } catch (Dali::DaliException e) {
41298       {
41299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41300       };
41301     } catch (...) {
41302       {
41303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41304       };
41305     }
41306   }
41307
41308   jresult = (void *)result;
41309   return jresult;
41310 }
41311
41312
41313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41314   Dali::PanGesture *arg1 = 0 ;
41315
41316   arg1 = (Dali::PanGesture *)jarg1;
41317   if (!arg1) {
41318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41319     return ;
41320   }
41321   {
41322     try {
41323       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41324     } catch (std::out_of_range& e) {
41325       {
41326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41327       };
41328     } catch (std::exception& e) {
41329       {
41330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41331       };
41332     } catch (Dali::DaliException e) {
41333       {
41334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41335       };
41336     } catch (...) {
41337       {
41338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41339       };
41340     }
41341   }
41342
41343 }
41344
41345
41346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41347   void * jresult ;
41348   Dali::PanGesture *result = 0 ;
41349
41350   {
41351     try {
41352       result = (Dali::PanGesture *)new Dali::PanGesture();
41353     } catch (std::out_of_range& e) {
41354       {
41355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41356       };
41357     } catch (std::exception& e) {
41358       {
41359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41360       };
41361     } catch (Dali::DaliException e) {
41362       {
41363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41364       };
41365     } catch (...) {
41366       {
41367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41368       };
41369     }
41370   }
41371
41372   jresult = (void *)result;
41373   return jresult;
41374 }
41375
41376
41377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41378   void * jresult ;
41379   Dali::Gesture::State arg1 ;
41380   Dali::PanGesture *result = 0 ;
41381
41382   arg1 = (Dali::Gesture::State)jarg1;
41383   {
41384     try {
41385       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41386     } catch (std::out_of_range& e) {
41387       {
41388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41389       };
41390     } catch (std::exception& e) {
41391       {
41392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41393       };
41394     } catch (Dali::DaliException e) {
41395       {
41396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41397       };
41398     } catch (...) {
41399       {
41400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41401       };
41402     }
41403   }
41404
41405   jresult = (void *)result;
41406   return jresult;
41407 }
41408
41409
41410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41411   void * jresult ;
41412   Dali::PanGesture *arg1 = 0 ;
41413   Dali::PanGesture *result = 0 ;
41414
41415   arg1 = (Dali::PanGesture *)jarg1;
41416   if (!arg1) {
41417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41418     return 0;
41419   }
41420   {
41421     try {
41422       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41423     } catch (std::out_of_range& e) {
41424       {
41425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41426       };
41427     } catch (std::exception& e) {
41428       {
41429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41430       };
41431     } catch (Dali::DaliException e) {
41432       {
41433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41434       };
41435     } catch (...) {
41436       {
41437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41438       };
41439     }
41440   }
41441
41442   jresult = (void *)result;
41443   return jresult;
41444 }
41445
41446
41447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41448   void * jresult ;
41449   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41450   Dali::PanGesture *arg2 = 0 ;
41451   Dali::PanGesture *result = 0 ;
41452
41453   arg1 = (Dali::PanGesture *)jarg1;
41454   arg2 = (Dali::PanGesture *)jarg2;
41455   if (!arg2) {
41456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41457     return 0;
41458   }
41459   {
41460     try {
41461       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41462     } catch (std::out_of_range& e) {
41463       {
41464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41465       };
41466     } catch (std::exception& e) {
41467       {
41468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41469       };
41470     } catch (Dali::DaliException e) {
41471       {
41472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41473       };
41474     } catch (...) {
41475       {
41476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41477       };
41478     }
41479   }
41480
41481   jresult = (void *)result;
41482   return jresult;
41483 }
41484
41485
41486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41487   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41488
41489   arg1 = (Dali::PanGesture *)jarg1;
41490   {
41491     try {
41492       delete arg1;
41493     } catch (std::out_of_range& e) {
41494       {
41495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41496       };
41497     } catch (std::exception& e) {
41498       {
41499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41500       };
41501     } catch (Dali::DaliException e) {
41502       {
41503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41504       };
41505     } catch (...) {
41506       {
41507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41508       };
41509     }
41510   }
41511
41512 }
41513
41514
41515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41516   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41517   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41518
41519   arg1 = (Dali::PanGesture *)jarg1;
41520   arg2 = (Dali::Vector2 *)jarg2;
41521   if (arg1) (arg1)->velocity = *arg2;
41522 }
41523
41524
41525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41526   void * jresult ;
41527   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41528   Dali::Vector2 *result = 0 ;
41529
41530   arg1 = (Dali::PanGesture *)jarg1;
41531   result = (Dali::Vector2 *)& ((arg1)->velocity);
41532   jresult = (void *)result;
41533   return jresult;
41534 }
41535
41536
41537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41538   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41539   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41540
41541   arg1 = (Dali::PanGesture *)jarg1;
41542   arg2 = (Dali::Vector2 *)jarg2;
41543   if (arg1) (arg1)->displacement = *arg2;
41544 }
41545
41546
41547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41548   void * jresult ;
41549   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41550   Dali::Vector2 *result = 0 ;
41551
41552   arg1 = (Dali::PanGesture *)jarg1;
41553   result = (Dali::Vector2 *)& ((arg1)->displacement);
41554   jresult = (void *)result;
41555   return jresult;
41556 }
41557
41558
41559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41560   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41561   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41562
41563   arg1 = (Dali::PanGesture *)jarg1;
41564   arg2 = (Dali::Vector2 *)jarg2;
41565   if (arg1) (arg1)->position = *arg2;
41566 }
41567
41568
41569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41570   void * jresult ;
41571   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41572   Dali::Vector2 *result = 0 ;
41573
41574   arg1 = (Dali::PanGesture *)jarg1;
41575   result = (Dali::Vector2 *)& ((arg1)->position);
41576   jresult = (void *)result;
41577   return jresult;
41578 }
41579
41580
41581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41582   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41583   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41584
41585   arg1 = (Dali::PanGesture *)jarg1;
41586   arg2 = (Dali::Vector2 *)jarg2;
41587   if (arg1) (arg1)->screenVelocity = *arg2;
41588 }
41589
41590
41591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41592   void * jresult ;
41593   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41594   Dali::Vector2 *result = 0 ;
41595
41596   arg1 = (Dali::PanGesture *)jarg1;
41597   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41598   jresult = (void *)result;
41599   return jresult;
41600 }
41601
41602
41603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41604   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41605   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41606
41607   arg1 = (Dali::PanGesture *)jarg1;
41608   arg2 = (Dali::Vector2 *)jarg2;
41609   if (arg1) (arg1)->screenDisplacement = *arg2;
41610 }
41611
41612
41613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41614   void * jresult ;
41615   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41616   Dali::Vector2 *result = 0 ;
41617
41618   arg1 = (Dali::PanGesture *)jarg1;
41619   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41620   jresult = (void *)result;
41621   return jresult;
41622 }
41623
41624
41625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41626   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41627   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41628
41629   arg1 = (Dali::PanGesture *)jarg1;
41630   arg2 = (Dali::Vector2 *)jarg2;
41631   if (arg1) (arg1)->screenPosition = *arg2;
41632 }
41633
41634
41635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41636   void * jresult ;
41637   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41638   Dali::Vector2 *result = 0 ;
41639
41640   arg1 = (Dali::PanGesture *)jarg1;
41641   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41642   jresult = (void *)result;
41643   return jresult;
41644 }
41645
41646
41647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41648   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41649   unsigned int arg2 ;
41650
41651   arg1 = (Dali::PanGesture *)jarg1;
41652   arg2 = (unsigned int)jarg2;
41653   if (arg1) (arg1)->numberOfTouches = arg2;
41654 }
41655
41656
41657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41658   unsigned int jresult ;
41659   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41660   unsigned int result;
41661
41662   arg1 = (Dali::PanGesture *)jarg1;
41663   result = (unsigned int) ((arg1)->numberOfTouches);
41664   jresult = result;
41665   return jresult;
41666 }
41667
41668
41669 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41670   float jresult ;
41671   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41672   float result;
41673
41674   arg1 = (Dali::PanGesture *)jarg1;
41675   {
41676     try {
41677       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41678     } catch (std::out_of_range& e) {
41679       {
41680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41681       };
41682     } catch (std::exception& e) {
41683       {
41684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41685       };
41686     } catch (Dali::DaliException e) {
41687       {
41688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41689       };
41690     } catch (...) {
41691       {
41692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41693       };
41694     }
41695   }
41696
41697   jresult = result;
41698   return jresult;
41699 }
41700
41701
41702 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41703   float jresult ;
41704   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41705   float result;
41706
41707   arg1 = (Dali::PanGesture *)jarg1;
41708   {
41709     try {
41710       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41711     } catch (std::out_of_range& e) {
41712       {
41713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41714       };
41715     } catch (std::exception& e) {
41716       {
41717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41718       };
41719     } catch (Dali::DaliException e) {
41720       {
41721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41722       };
41723     } catch (...) {
41724       {
41725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41726       };
41727     }
41728   }
41729
41730   jresult = result;
41731   return jresult;
41732 }
41733
41734
41735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41736   float jresult ;
41737   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41738   float result;
41739
41740   arg1 = (Dali::PanGesture *)jarg1;
41741   {
41742     try {
41743       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41744     } catch (std::out_of_range& e) {
41745       {
41746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41747       };
41748     } catch (std::exception& e) {
41749       {
41750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41751       };
41752     } catch (Dali::DaliException e) {
41753       {
41754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41755       };
41756     } catch (...) {
41757       {
41758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41759       };
41760     }
41761   }
41762
41763   jresult = result;
41764   return jresult;
41765 }
41766
41767
41768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41769   float jresult ;
41770   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41771   float result;
41772
41773   arg1 = (Dali::PanGesture *)jarg1;
41774   {
41775     try {
41776       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41777     } catch (std::out_of_range& e) {
41778       {
41779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41780       };
41781     } catch (std::exception& e) {
41782       {
41783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41784       };
41785     } catch (Dali::DaliException e) {
41786       {
41787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41788       };
41789     } catch (...) {
41790       {
41791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41792       };
41793     }
41794   }
41795
41796   jresult = result;
41797   return jresult;
41798 }
41799
41800
41801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41802   void * jresult ;
41803   Dali::PinchGestureDetector *result = 0 ;
41804
41805   {
41806     try {
41807       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41808     } catch (std::out_of_range& e) {
41809       {
41810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41811       };
41812     } catch (std::exception& e) {
41813       {
41814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41815       };
41816     } catch (Dali::DaliException e) {
41817       {
41818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41819       };
41820     } catch (...) {
41821       {
41822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41823       };
41824     }
41825   }
41826
41827   jresult = (void *)result;
41828   return jresult;
41829 }
41830
41831
41832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41833   void * jresult ;
41834   Dali::PinchGestureDetector result;
41835
41836   {
41837     try {
41838       result = Dali::PinchGestureDetector::New();
41839     } catch (std::out_of_range& e) {
41840       {
41841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41842       };
41843     } catch (std::exception& e) {
41844       {
41845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41846       };
41847     } catch (Dali::DaliException e) {
41848       {
41849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41850       };
41851     } catch (...) {
41852       {
41853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41854       };
41855     }
41856   }
41857
41858   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41859   return jresult;
41860 }
41861
41862
41863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41864   void * jresult ;
41865   Dali::BaseHandle arg1 ;
41866   Dali::BaseHandle *argp1 ;
41867   Dali::PinchGestureDetector result;
41868
41869   argp1 = (Dali::BaseHandle *)jarg1;
41870   if (!argp1) {
41871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41872     return 0;
41873   }
41874   arg1 = *argp1;
41875   {
41876     try {
41877       result = Dali::PinchGestureDetector::DownCast(arg1);
41878     } catch (std::out_of_range& e) {
41879       {
41880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41881       };
41882     } catch (std::exception& e) {
41883       {
41884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41885       };
41886     } catch (Dali::DaliException e) {
41887       {
41888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41889       };
41890     } catch (...) {
41891       {
41892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41893       };
41894     }
41895   }
41896
41897   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41898   return jresult;
41899 }
41900
41901
41902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41903   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41904
41905   arg1 = (Dali::PinchGestureDetector *)jarg1;
41906   {
41907     try {
41908       delete arg1;
41909     } catch (std::out_of_range& e) {
41910       {
41911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41912       };
41913     } catch (std::exception& e) {
41914       {
41915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41916       };
41917     } catch (Dali::DaliException e) {
41918       {
41919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41920       };
41921     } catch (...) {
41922       {
41923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41924       };
41925     }
41926   }
41927
41928 }
41929
41930
41931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41932   void * jresult ;
41933   Dali::PinchGestureDetector *arg1 = 0 ;
41934   Dali::PinchGestureDetector *result = 0 ;
41935
41936   arg1 = (Dali::PinchGestureDetector *)jarg1;
41937   if (!arg1) {
41938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41939     return 0;
41940   }
41941   {
41942     try {
41943       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41944     } catch (std::out_of_range& e) {
41945       {
41946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41947       };
41948     } catch (std::exception& e) {
41949       {
41950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41951       };
41952     } catch (Dali::DaliException e) {
41953       {
41954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41955       };
41956     } catch (...) {
41957       {
41958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41959       };
41960     }
41961   }
41962
41963   jresult = (void *)result;
41964   return jresult;
41965 }
41966
41967
41968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41969   void * jresult ;
41970   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41971   Dali::PinchGestureDetector *arg2 = 0 ;
41972   Dali::PinchGestureDetector *result = 0 ;
41973
41974   arg1 = (Dali::PinchGestureDetector *)jarg1;
41975   arg2 = (Dali::PinchGestureDetector *)jarg2;
41976   if (!arg2) {
41977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41978     return 0;
41979   }
41980   {
41981     try {
41982       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41983     } catch (std::out_of_range& e) {
41984       {
41985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41986       };
41987     } catch (std::exception& e) {
41988       {
41989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41990       };
41991     } catch (Dali::DaliException e) {
41992       {
41993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41994       };
41995     } catch (...) {
41996       {
41997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41998       };
41999     }
42000   }
42001
42002   jresult = (void *)result;
42003   return jresult;
42004 }
42005
42006
42007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42008   void * jresult ;
42009   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42010   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42011
42012   arg1 = (Dali::PinchGestureDetector *)jarg1;
42013   {
42014     try {
42015       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42016     } catch (std::out_of_range& e) {
42017       {
42018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42019       };
42020     } catch (std::exception& e) {
42021       {
42022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42023       };
42024     } catch (Dali::DaliException e) {
42025       {
42026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42027       };
42028     } catch (...) {
42029       {
42030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42031       };
42032     }
42033   }
42034
42035   jresult = (void *)result;
42036   return jresult;
42037 }
42038
42039
42040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42041   void * jresult ;
42042   Dali::Gesture::State arg1 ;
42043   Dali::PinchGesture *result = 0 ;
42044
42045   arg1 = (Dali::Gesture::State)jarg1;
42046   {
42047     try {
42048       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42049     } catch (std::out_of_range& e) {
42050       {
42051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42052       };
42053     } catch (std::exception& e) {
42054       {
42055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42056       };
42057     } catch (Dali::DaliException e) {
42058       {
42059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42060       };
42061     } catch (...) {
42062       {
42063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42064       };
42065     }
42066   }
42067
42068   jresult = (void *)result;
42069   return jresult;
42070 }
42071
42072
42073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42074   void * jresult ;
42075   Dali::PinchGesture *arg1 = 0 ;
42076   Dali::PinchGesture *result = 0 ;
42077
42078   arg1 = (Dali::PinchGesture *)jarg1;
42079   if (!arg1) {
42080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42081     return 0;
42082   }
42083   {
42084     try {
42085       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42086     } catch (std::out_of_range& e) {
42087       {
42088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42089       };
42090     } catch (std::exception& e) {
42091       {
42092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42093       };
42094     } catch (Dali::DaliException e) {
42095       {
42096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42097       };
42098     } catch (...) {
42099       {
42100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42101       };
42102     }
42103   }
42104
42105   jresult = (void *)result;
42106   return jresult;
42107 }
42108
42109
42110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42111   void * jresult ;
42112   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42113   Dali::PinchGesture *arg2 = 0 ;
42114   Dali::PinchGesture *result = 0 ;
42115
42116   arg1 = (Dali::PinchGesture *)jarg1;
42117   arg2 = (Dali::PinchGesture *)jarg2;
42118   if (!arg2) {
42119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42120     return 0;
42121   }
42122   {
42123     try {
42124       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42125     } catch (std::out_of_range& e) {
42126       {
42127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42128       };
42129     } catch (std::exception& e) {
42130       {
42131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42132       };
42133     } catch (Dali::DaliException e) {
42134       {
42135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42136       };
42137     } catch (...) {
42138       {
42139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42140       };
42141     }
42142   }
42143
42144   jresult = (void *)result;
42145   return jresult;
42146 }
42147
42148
42149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42150   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42151
42152   arg1 = (Dali::PinchGesture *)jarg1;
42153   {
42154     try {
42155       delete arg1;
42156     } catch (std::out_of_range& e) {
42157       {
42158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42159       };
42160     } catch (std::exception& e) {
42161       {
42162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42163       };
42164     } catch (Dali::DaliException e) {
42165       {
42166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42167       };
42168     } catch (...) {
42169       {
42170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42171       };
42172     }
42173   }
42174
42175 }
42176
42177
42178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42179   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42180   float arg2 ;
42181
42182   arg1 = (Dali::PinchGesture *)jarg1;
42183   arg2 = (float)jarg2;
42184   if (arg1) (arg1)->scale = arg2;
42185 }
42186
42187
42188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42189   float jresult ;
42190   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42191   float result;
42192
42193   arg1 = (Dali::PinchGesture *)jarg1;
42194   result = (float) ((arg1)->scale);
42195   jresult = result;
42196   return jresult;
42197 }
42198
42199
42200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42201   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42202   float arg2 ;
42203
42204   arg1 = (Dali::PinchGesture *)jarg1;
42205   arg2 = (float)jarg2;
42206   if (arg1) (arg1)->speed = arg2;
42207 }
42208
42209
42210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42211   float jresult ;
42212   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42213   float result;
42214
42215   arg1 = (Dali::PinchGesture *)jarg1;
42216   result = (float) ((arg1)->speed);
42217   jresult = result;
42218   return jresult;
42219 }
42220
42221
42222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42223   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42224   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42225
42226   arg1 = (Dali::PinchGesture *)jarg1;
42227   arg2 = (Dali::Vector2 *)jarg2;
42228   if (arg1) (arg1)->screenCenterPoint = *arg2;
42229 }
42230
42231
42232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42233   void * jresult ;
42234   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42235   Dali::Vector2 *result = 0 ;
42236
42237   arg1 = (Dali::PinchGesture *)jarg1;
42238   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42239   jresult = (void *)result;
42240   return jresult;
42241 }
42242
42243
42244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42245   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42246   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42247
42248   arg1 = (Dali::PinchGesture *)jarg1;
42249   arg2 = (Dali::Vector2 *)jarg2;
42250   if (arg1) (arg1)->localCenterPoint = *arg2;
42251 }
42252
42253
42254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42255   void * jresult ;
42256   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42257   Dali::Vector2 *result = 0 ;
42258
42259   arg1 = (Dali::PinchGesture *)jarg1;
42260   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42261   jresult = (void *)result;
42262   return jresult;
42263 }
42264
42265
42266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42267   void * jresult ;
42268   Dali::TapGestureDetector *result = 0 ;
42269
42270   {
42271     try {
42272       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42273     } catch (std::out_of_range& e) {
42274       {
42275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42276       };
42277     } catch (std::exception& e) {
42278       {
42279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42280       };
42281     } catch (Dali::DaliException e) {
42282       {
42283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42284       };
42285     } catch (...) {
42286       {
42287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42288       };
42289     }
42290   }
42291
42292   jresult = (void *)result;
42293   return jresult;
42294 }
42295
42296
42297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42298   void * jresult ;
42299   Dali::TapGestureDetector result;
42300
42301   {
42302     try {
42303       result = Dali::TapGestureDetector::New();
42304     } catch (std::out_of_range& e) {
42305       {
42306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42307       };
42308     } catch (std::exception& e) {
42309       {
42310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42311       };
42312     } catch (Dali::DaliException e) {
42313       {
42314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42315       };
42316     } catch (...) {
42317       {
42318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42319       };
42320     }
42321   }
42322
42323   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42324   return jresult;
42325 }
42326
42327
42328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42329   void * jresult ;
42330   unsigned int arg1 ;
42331   Dali::TapGestureDetector result;
42332
42333   arg1 = (unsigned int)jarg1;
42334   {
42335     try {
42336       result = Dali::TapGestureDetector::New(arg1);
42337     } catch (std::out_of_range& e) {
42338       {
42339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42340       };
42341     } catch (std::exception& e) {
42342       {
42343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42344       };
42345     } catch (Dali::DaliException e) {
42346       {
42347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42348       };
42349     } catch (...) {
42350       {
42351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42352       };
42353     }
42354   }
42355
42356   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42357   return jresult;
42358 }
42359
42360
42361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42362   void * jresult ;
42363   Dali::BaseHandle arg1 ;
42364   Dali::BaseHandle *argp1 ;
42365   Dali::TapGestureDetector result;
42366
42367   argp1 = (Dali::BaseHandle *)jarg1;
42368   if (!argp1) {
42369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42370     return 0;
42371   }
42372   arg1 = *argp1;
42373   {
42374     try {
42375       result = Dali::TapGestureDetector::DownCast(arg1);
42376     } catch (std::out_of_range& e) {
42377       {
42378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42379       };
42380     } catch (std::exception& e) {
42381       {
42382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42383       };
42384     } catch (Dali::DaliException e) {
42385       {
42386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42387       };
42388     } catch (...) {
42389       {
42390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42391       };
42392     }
42393   }
42394
42395   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42396   return jresult;
42397 }
42398
42399
42400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42401   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42402
42403   arg1 = (Dali::TapGestureDetector *)jarg1;
42404   {
42405     try {
42406       delete arg1;
42407     } catch (std::out_of_range& e) {
42408       {
42409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42410       };
42411     } catch (std::exception& e) {
42412       {
42413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42414       };
42415     } catch (Dali::DaliException e) {
42416       {
42417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42418       };
42419     } catch (...) {
42420       {
42421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42422       };
42423     }
42424   }
42425
42426 }
42427
42428
42429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42430   void * jresult ;
42431   Dali::TapGestureDetector *arg1 = 0 ;
42432   Dali::TapGestureDetector *result = 0 ;
42433
42434   arg1 = (Dali::TapGestureDetector *)jarg1;
42435   if (!arg1) {
42436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42437     return 0;
42438   }
42439   {
42440     try {
42441       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42442     } catch (std::out_of_range& e) {
42443       {
42444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42445       };
42446     } catch (std::exception& e) {
42447       {
42448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42449       };
42450     } catch (Dali::DaliException e) {
42451       {
42452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42453       };
42454     } catch (...) {
42455       {
42456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42457       };
42458     }
42459   }
42460
42461   jresult = (void *)result;
42462   return jresult;
42463 }
42464
42465
42466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42467   void * jresult ;
42468   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42469   Dali::TapGestureDetector *arg2 = 0 ;
42470   Dali::TapGestureDetector *result = 0 ;
42471
42472   arg1 = (Dali::TapGestureDetector *)jarg1;
42473   arg2 = (Dali::TapGestureDetector *)jarg2;
42474   if (!arg2) {
42475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42476     return 0;
42477   }
42478   {
42479     try {
42480       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42481     } catch (std::out_of_range& e) {
42482       {
42483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42484       };
42485     } catch (std::exception& e) {
42486       {
42487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42488       };
42489     } catch (Dali::DaliException e) {
42490       {
42491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42492       };
42493     } catch (...) {
42494       {
42495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42496       };
42497     }
42498   }
42499
42500   jresult = (void *)result;
42501   return jresult;
42502 }
42503
42504
42505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42506   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42507   unsigned int arg2 ;
42508
42509   arg1 = (Dali::TapGestureDetector *)jarg1;
42510   arg2 = (unsigned int)jarg2;
42511   {
42512     try {
42513       (arg1)->SetMinimumTapsRequired(arg2);
42514     } catch (std::out_of_range& e) {
42515       {
42516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42517       };
42518     } catch (std::exception& e) {
42519       {
42520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42521       };
42522     } catch (Dali::DaliException e) {
42523       {
42524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42525       };
42526     } catch (...) {
42527       {
42528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42529       };
42530     }
42531   }
42532
42533 }
42534
42535
42536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42537   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42538   unsigned int arg2 ;
42539
42540   arg1 = (Dali::TapGestureDetector *)jarg1;
42541   arg2 = (unsigned int)jarg2;
42542   {
42543     try {
42544       (arg1)->SetMaximumTapsRequired(arg2);
42545     } catch (std::out_of_range& e) {
42546       {
42547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42548       };
42549     } catch (std::exception& e) {
42550       {
42551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42552       };
42553     } catch (Dali::DaliException e) {
42554       {
42555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42556       };
42557     } catch (...) {
42558       {
42559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42560       };
42561     }
42562   }
42563
42564 }
42565
42566
42567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42568   unsigned int jresult ;
42569   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42570   unsigned int result;
42571
42572   arg1 = (Dali::TapGestureDetector *)jarg1;
42573   {
42574     try {
42575       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42576     } catch (std::out_of_range& e) {
42577       {
42578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42579       };
42580     } catch (std::exception& e) {
42581       {
42582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42583       };
42584     } catch (Dali::DaliException e) {
42585       {
42586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42587       };
42588     } catch (...) {
42589       {
42590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42591       };
42592     }
42593   }
42594
42595   jresult = result;
42596   return jresult;
42597 }
42598
42599
42600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42601   unsigned int jresult ;
42602   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42603   unsigned int result;
42604
42605   arg1 = (Dali::TapGestureDetector *)jarg1;
42606   {
42607     try {
42608       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42609     } catch (std::out_of_range& e) {
42610       {
42611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42612       };
42613     } catch (std::exception& e) {
42614       {
42615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42616       };
42617     } catch (Dali::DaliException e) {
42618       {
42619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42620       };
42621     } catch (...) {
42622       {
42623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42624       };
42625     }
42626   }
42627
42628   jresult = result;
42629   return jresult;
42630 }
42631
42632
42633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42634   void * jresult ;
42635   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42636   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42637
42638   arg1 = (Dali::TapGestureDetector *)jarg1;
42639   {
42640     try {
42641       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42642     } catch (std::out_of_range& e) {
42643       {
42644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42645       };
42646     } catch (std::exception& e) {
42647       {
42648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42649       };
42650     } catch (Dali::DaliException e) {
42651       {
42652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42653       };
42654     } catch (...) {
42655       {
42656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42657       };
42658     }
42659   }
42660
42661   jresult = (void *)result;
42662   return jresult;
42663 }
42664
42665
42666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42667   void * jresult ;
42668   Dali::TapGesture *result = 0 ;
42669
42670   {
42671     try {
42672       result = (Dali::TapGesture *)new Dali::TapGesture();
42673     } catch (std::out_of_range& e) {
42674       {
42675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42676       };
42677     } catch (std::exception& e) {
42678       {
42679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42680       };
42681     } catch (Dali::DaliException e) {
42682       {
42683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42684       };
42685     } catch (...) {
42686       {
42687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42688       };
42689     }
42690   }
42691
42692   jresult = (void *)result;
42693   return jresult;
42694 }
42695
42696
42697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42698   void * jresult ;
42699   Dali::TapGesture *arg1 = 0 ;
42700   Dali::TapGesture *result = 0 ;
42701
42702   arg1 = (Dali::TapGesture *)jarg1;
42703   if (!arg1) {
42704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42705     return 0;
42706   }
42707   {
42708     try {
42709       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42710     } catch (std::out_of_range& e) {
42711       {
42712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42713       };
42714     } catch (std::exception& e) {
42715       {
42716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42717       };
42718     } catch (Dali::DaliException e) {
42719       {
42720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42721       };
42722     } catch (...) {
42723       {
42724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42725       };
42726     }
42727   }
42728
42729   jresult = (void *)result;
42730   return jresult;
42731 }
42732
42733
42734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42735   void * jresult ;
42736   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42737   Dali::TapGesture *arg2 = 0 ;
42738   Dali::TapGesture *result = 0 ;
42739
42740   arg1 = (Dali::TapGesture *)jarg1;
42741   arg2 = (Dali::TapGesture *)jarg2;
42742   if (!arg2) {
42743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42744     return 0;
42745   }
42746   {
42747     try {
42748       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42749     } catch (std::out_of_range& e) {
42750       {
42751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42752       };
42753     } catch (std::exception& e) {
42754       {
42755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42756       };
42757     } catch (Dali::DaliException e) {
42758       {
42759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42760       };
42761     } catch (...) {
42762       {
42763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42764       };
42765     }
42766   }
42767
42768   jresult = (void *)result;
42769   return jresult;
42770 }
42771
42772
42773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42774   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42775
42776   arg1 = (Dali::TapGesture *)jarg1;
42777   {
42778     try {
42779       delete arg1;
42780     } catch (std::out_of_range& e) {
42781       {
42782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42783       };
42784     } catch (std::exception& e) {
42785       {
42786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42787       };
42788     } catch (Dali::DaliException e) {
42789       {
42790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42791       };
42792     } catch (...) {
42793       {
42794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42795       };
42796     }
42797   }
42798
42799 }
42800
42801
42802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42803   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42804   unsigned int arg2 ;
42805
42806   arg1 = (Dali::TapGesture *)jarg1;
42807   arg2 = (unsigned int)jarg2;
42808   if (arg1) (arg1)->numberOfTaps = arg2;
42809 }
42810
42811
42812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42813   unsigned int jresult ;
42814   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42815   unsigned int result;
42816
42817   arg1 = (Dali::TapGesture *)jarg1;
42818   result = (unsigned int) ((arg1)->numberOfTaps);
42819   jresult = result;
42820   return jresult;
42821 }
42822
42823
42824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42825   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42826   unsigned int arg2 ;
42827
42828   arg1 = (Dali::TapGesture *)jarg1;
42829   arg2 = (unsigned int)jarg2;
42830   if (arg1) (arg1)->numberOfTouches = arg2;
42831 }
42832
42833
42834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42835   unsigned int jresult ;
42836   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42837   unsigned int result;
42838
42839   arg1 = (Dali::TapGesture *)jarg1;
42840   result = (unsigned int) ((arg1)->numberOfTouches);
42841   jresult = result;
42842   return jresult;
42843 }
42844
42845
42846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42847   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42848   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42849
42850   arg1 = (Dali::TapGesture *)jarg1;
42851   arg2 = (Dali::Vector2 *)jarg2;
42852   if (arg1) (arg1)->screenPoint = *arg2;
42853 }
42854
42855
42856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42857   void * jresult ;
42858   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42859   Dali::Vector2 *result = 0 ;
42860
42861   arg1 = (Dali::TapGesture *)jarg1;
42862   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42863   jresult = (void *)result;
42864   return jresult;
42865 }
42866
42867
42868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42869   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42870   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42871
42872   arg1 = (Dali::TapGesture *)jarg1;
42873   arg2 = (Dali::Vector2 *)jarg2;
42874   if (arg1) (arg1)->localPoint = *arg2;
42875 }
42876
42877
42878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42879   void * jresult ;
42880   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42881   Dali::Vector2 *result = 0 ;
42882
42883   arg1 = (Dali::TapGesture *)jarg1;
42884   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42885   jresult = (void *)result;
42886   return jresult;
42887 }
42888
42889
42890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42891   void * jresult ;
42892   Dali::AlphaFunction *result = 0 ;
42893
42894   {
42895     try {
42896       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42897     } catch (std::out_of_range& e) {
42898       {
42899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42900       };
42901     } catch (std::exception& e) {
42902       {
42903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42904       };
42905     } catch (Dali::DaliException e) {
42906       {
42907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42908       };
42909     } catch (...) {
42910       {
42911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42912       };
42913     }
42914   }
42915
42916   jresult = (void *)result;
42917   return jresult;
42918 }
42919
42920
42921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42922   void * jresult ;
42923   Dali::AlphaFunction::BuiltinFunction arg1 ;
42924   Dali::AlphaFunction *result = 0 ;
42925
42926   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42927   {
42928     try {
42929       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42930     } catch (std::out_of_range& e) {
42931       {
42932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42933       };
42934     } catch (std::exception& e) {
42935       {
42936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42937       };
42938     } catch (Dali::DaliException e) {
42939       {
42940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42941       };
42942     } catch (...) {
42943       {
42944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42945       };
42946     }
42947   }
42948
42949   jresult = (void *)result;
42950   return jresult;
42951 }
42952
42953
42954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42955   void * jresult ;
42956   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42957   Dali::AlphaFunction *result = 0 ;
42958
42959   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42960   {
42961     try {
42962       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42963     } catch (std::out_of_range& e) {
42964       {
42965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42966       };
42967     } catch (std::exception& e) {
42968       {
42969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42970       };
42971     } catch (Dali::DaliException e) {
42972       {
42973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42974       };
42975     } catch (...) {
42976       {
42977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42978       };
42979     }
42980   }
42981
42982   jresult = (void *)result;
42983   return jresult;
42984 }
42985
42986
42987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42988   void * jresult ;
42989   Dali::Vector2 *arg1 = 0 ;
42990   Dali::Vector2 *arg2 = 0 ;
42991   Dali::AlphaFunction *result = 0 ;
42992
42993   arg1 = (Dali::Vector2 *)jarg1;
42994   if (!arg1) {
42995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42996     return 0;
42997   }
42998   arg2 = (Dali::Vector2 *)jarg2;
42999   if (!arg2) {
43000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43001     return 0;
43002   }
43003   {
43004     try {
43005       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43006     } catch (std::out_of_range& e) {
43007       {
43008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43009       };
43010     } catch (std::exception& e) {
43011       {
43012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43013       };
43014     } catch (Dali::DaliException e) {
43015       {
43016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43017       };
43018     } catch (...) {
43019       {
43020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43021       };
43022     }
43023   }
43024
43025   jresult = (void *)result;
43026   return jresult;
43027 }
43028
43029
43030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43031   void * jresult ;
43032   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43033   Dali::Vector4 result;
43034
43035   arg1 = (Dali::AlphaFunction *)jarg1;
43036   {
43037     try {
43038       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43039     } catch (std::out_of_range& e) {
43040       {
43041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43042       };
43043     } catch (std::exception& e) {
43044       {
43045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43046       };
43047     } catch (Dali::DaliException e) {
43048       {
43049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43050       };
43051     } catch (...) {
43052       {
43053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43054       };
43055     }
43056   }
43057
43058   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43059   return jresult;
43060 }
43061
43062
43063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43064   void * jresult ;
43065   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43066   Dali::AlphaFunctionPrototype result;
43067
43068   arg1 = (Dali::AlphaFunction *)jarg1;
43069   {
43070     try {
43071       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43072     } catch (std::out_of_range& e) {
43073       {
43074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43075       };
43076     } catch (std::exception& e) {
43077       {
43078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43079       };
43080     } catch (Dali::DaliException e) {
43081       {
43082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43083       };
43084     } catch (...) {
43085       {
43086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43087       };
43088     }
43089   }
43090
43091   jresult = (void *)result;
43092   return jresult;
43093 }
43094
43095
43096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43097   int jresult ;
43098   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43099   Dali::AlphaFunction::BuiltinFunction result;
43100
43101   arg1 = (Dali::AlphaFunction *)jarg1;
43102   {
43103     try {
43104       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43105     } catch (std::out_of_range& e) {
43106       {
43107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43108       };
43109     } catch (std::exception& e) {
43110       {
43111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43112       };
43113     } catch (Dali::DaliException e) {
43114       {
43115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43116       };
43117     } catch (...) {
43118       {
43119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43120       };
43121     }
43122   }
43123
43124   jresult = (int)result;
43125   return jresult;
43126 }
43127
43128
43129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43130   int jresult ;
43131   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43132   Dali::AlphaFunction::Mode result;
43133
43134   arg1 = (Dali::AlphaFunction *)jarg1;
43135   {
43136     try {
43137       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43138     } catch (std::out_of_range& e) {
43139       {
43140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43141       };
43142     } catch (std::exception& e) {
43143       {
43144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43145       };
43146     } catch (Dali::DaliException e) {
43147       {
43148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43149       };
43150     } catch (...) {
43151       {
43152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43153       };
43154     }
43155   }
43156
43157   jresult = (int)result;
43158   return jresult;
43159 }
43160
43161
43162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43163   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43164
43165   arg1 = (Dali::AlphaFunction *)jarg1;
43166   {
43167     try {
43168       delete arg1;
43169     } catch (std::out_of_range& e) {
43170       {
43171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43172       };
43173     } catch (std::exception& e) {
43174       {
43175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43176       };
43177     } catch (Dali::DaliException e) {
43178       {
43179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43180       };
43181     } catch (...) {
43182       {
43183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43184       };
43185     }
43186   }
43187
43188 }
43189
43190
43191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43192   void * jresult ;
43193   Dali::KeyFrames result;
43194
43195   {
43196     try {
43197       result = Dali::KeyFrames::New();
43198     } catch (std::out_of_range& e) {
43199       {
43200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43201       };
43202     } catch (std::exception& e) {
43203       {
43204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43205       };
43206     } catch (Dali::DaliException e) {
43207       {
43208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43209       };
43210     } catch (...) {
43211       {
43212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43213       };
43214     }
43215   }
43216
43217   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43218   return jresult;
43219 }
43220
43221
43222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43223   void * jresult ;
43224   Dali::BaseHandle arg1 ;
43225   Dali::BaseHandle *argp1 ;
43226   Dali::KeyFrames result;
43227
43228   argp1 = (Dali::BaseHandle *)jarg1;
43229   if (!argp1) {
43230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43231     return 0;
43232   }
43233   arg1 = *argp1;
43234   {
43235     try {
43236       result = Dali::KeyFrames::DownCast(arg1);
43237     } catch (std::out_of_range& e) {
43238       {
43239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43240       };
43241     } catch (std::exception& e) {
43242       {
43243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43244       };
43245     } catch (Dali::DaliException e) {
43246       {
43247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43248       };
43249     } catch (...) {
43250       {
43251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43252       };
43253     }
43254   }
43255
43256   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43257   return jresult;
43258 }
43259
43260
43261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43262   void * jresult ;
43263   Dali::KeyFrames *result = 0 ;
43264
43265   {
43266     try {
43267       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43268     } catch (std::out_of_range& e) {
43269       {
43270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43271       };
43272     } catch (std::exception& e) {
43273       {
43274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43275       };
43276     } catch (Dali::DaliException e) {
43277       {
43278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43279       };
43280     } catch (...) {
43281       {
43282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43283       };
43284     }
43285   }
43286
43287   jresult = (void *)result;
43288   return jresult;
43289 }
43290
43291
43292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43293   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43294
43295   arg1 = (Dali::KeyFrames *)jarg1;
43296   {
43297     try {
43298       delete arg1;
43299     } catch (std::out_of_range& e) {
43300       {
43301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43302       };
43303     } catch (std::exception& e) {
43304       {
43305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43306       };
43307     } catch (Dali::DaliException e) {
43308       {
43309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43310       };
43311     } catch (...) {
43312       {
43313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43314       };
43315     }
43316   }
43317
43318 }
43319
43320
43321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43322   void * jresult ;
43323   Dali::KeyFrames *arg1 = 0 ;
43324   Dali::KeyFrames *result = 0 ;
43325
43326   arg1 = (Dali::KeyFrames *)jarg1;
43327   if (!arg1) {
43328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43329     return 0;
43330   }
43331   {
43332     try {
43333       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43334     } catch (std::out_of_range& e) {
43335       {
43336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43337       };
43338     } catch (std::exception& e) {
43339       {
43340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43341       };
43342     } catch (Dali::DaliException e) {
43343       {
43344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43345       };
43346     } catch (...) {
43347       {
43348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43349       };
43350     }
43351   }
43352
43353   jresult = (void *)result;
43354   return jresult;
43355 }
43356
43357
43358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43359   void * jresult ;
43360   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43361   Dali::KeyFrames *arg2 = 0 ;
43362   Dali::KeyFrames *result = 0 ;
43363
43364   arg1 = (Dali::KeyFrames *)jarg1;
43365   arg2 = (Dali::KeyFrames *)jarg2;
43366   if (!arg2) {
43367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43368     return 0;
43369   }
43370   {
43371     try {
43372       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43373     } catch (std::out_of_range& e) {
43374       {
43375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43376       };
43377     } catch (std::exception& e) {
43378       {
43379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43380       };
43381     } catch (Dali::DaliException e) {
43382       {
43383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43384       };
43385     } catch (...) {
43386       {
43387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43388       };
43389     }
43390   }
43391
43392   jresult = (void *)result;
43393   return jresult;
43394 }
43395
43396
43397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43398   int jresult ;
43399   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43400   Dali::Property::Type result;
43401
43402   arg1 = (Dali::KeyFrames *)jarg1;
43403   {
43404     try {
43405       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43406     } catch (std::out_of_range& e) {
43407       {
43408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43409       };
43410     } catch (std::exception& e) {
43411       {
43412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43413       };
43414     } catch (Dali::DaliException e) {
43415       {
43416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43417       };
43418     } catch (...) {
43419       {
43420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43421       };
43422     }
43423   }
43424
43425   jresult = (int)result;
43426   return jresult;
43427 }
43428
43429
43430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43431   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43432   float arg2 ;
43433   Dali::Property::Value arg3 ;
43434   Dali::Property::Value *argp3 ;
43435
43436   arg1 = (Dali::KeyFrames *)jarg1;
43437   arg2 = (float)jarg2;
43438   argp3 = (Dali::Property::Value *)jarg3;
43439   if (!argp3) {
43440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43441     return ;
43442   }
43443   arg3 = *argp3;
43444   {
43445     try {
43446       (arg1)->Add(arg2,arg3);
43447     } catch (std::out_of_range& e) {
43448       {
43449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43450       };
43451     } catch (std::exception& e) {
43452       {
43453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43454       };
43455     } catch (Dali::DaliException e) {
43456       {
43457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43458       };
43459     } catch (...) {
43460       {
43461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43462       };
43463     }
43464   }
43465
43466 }
43467
43468
43469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43470   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43471   float arg2 ;
43472   Dali::Property::Value arg3 ;
43473   Dali::AlphaFunction arg4 ;
43474   Dali::Property::Value *argp3 ;
43475   Dali::AlphaFunction *argp4 ;
43476
43477   arg1 = (Dali::KeyFrames *)jarg1;
43478   arg2 = (float)jarg2;
43479   argp3 = (Dali::Property::Value *)jarg3;
43480   if (!argp3) {
43481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43482     return ;
43483   }
43484   arg3 = *argp3;
43485   argp4 = (Dali::AlphaFunction *)jarg4;
43486   if (!argp4) {
43487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43488     return ;
43489   }
43490   arg4 = *argp4;
43491   {
43492     try {
43493       (arg1)->Add(arg2,arg3,arg4);
43494     } catch (std::out_of_range& e) {
43495       {
43496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43497       };
43498     } catch (std::exception& e) {
43499       {
43500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43501       };
43502     } catch (Dali::DaliException e) {
43503       {
43504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43505       };
43506     } catch (...) {
43507       {
43508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43509       };
43510     }
43511   }
43512
43513 }
43514
43515
43516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43517   int jresult ;
43518   int result;
43519
43520   result = (int)Dali::Path::Property::POINTS;
43521   jresult = (int)result;
43522   return jresult;
43523 }
43524
43525
43526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43527   int jresult ;
43528   int result;
43529
43530   result = (int)Dali::Path::Property::CONTROL_POINTS;
43531   jresult = (int)result;
43532   return jresult;
43533 }
43534
43535
43536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43537   void * jresult ;
43538   Dali::Path::Property *result = 0 ;
43539
43540   {
43541     try {
43542       result = (Dali::Path::Property *)new Dali::Path::Property();
43543     } catch (std::out_of_range& e) {
43544       {
43545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43546       };
43547     } catch (std::exception& e) {
43548       {
43549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43550       };
43551     } catch (Dali::DaliException e) {
43552       {
43553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43554       };
43555     } catch (...) {
43556       {
43557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43558       };
43559     }
43560   }
43561
43562   jresult = (void *)result;
43563   return jresult;
43564 }
43565
43566
43567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43568   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43569
43570   arg1 = (Dali::Path::Property *)jarg1;
43571   {
43572     try {
43573       delete arg1;
43574     } catch (std::out_of_range& e) {
43575       {
43576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43577       };
43578     } catch (std::exception& e) {
43579       {
43580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43581       };
43582     } catch (Dali::DaliException e) {
43583       {
43584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43585       };
43586     } catch (...) {
43587       {
43588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43589       };
43590     }
43591   }
43592
43593 }
43594
43595
43596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43597   void * jresult ;
43598   Dali::Path result;
43599
43600   {
43601     try {
43602       result = Dali::Path::New();
43603     } catch (std::out_of_range& e) {
43604       {
43605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43606       };
43607     } catch (std::exception& e) {
43608       {
43609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43610       };
43611     } catch (Dali::DaliException e) {
43612       {
43613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43614       };
43615     } catch (...) {
43616       {
43617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43618       };
43619     }
43620   }
43621
43622   jresult = new Dali::Path((const Dali::Path &)result);
43623   return jresult;
43624 }
43625
43626
43627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43628   void * jresult ;
43629   Dali::BaseHandle arg1 ;
43630   Dali::BaseHandle *argp1 ;
43631   Dali::Path result;
43632
43633   argp1 = (Dali::BaseHandle *)jarg1;
43634   if (!argp1) {
43635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43636     return 0;
43637   }
43638   arg1 = *argp1;
43639   {
43640     try {
43641       result = Dali::Path::DownCast(arg1);
43642     } catch (std::out_of_range& e) {
43643       {
43644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43645       };
43646     } catch (std::exception& e) {
43647       {
43648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43649       };
43650     } catch (Dali::DaliException e) {
43651       {
43652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43653       };
43654     } catch (...) {
43655       {
43656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43657       };
43658     }
43659   }
43660
43661   jresult = new Dali::Path((const Dali::Path &)result);
43662   return jresult;
43663 }
43664
43665
43666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43667   void * jresult ;
43668   Dali::Path *result = 0 ;
43669
43670   {
43671     try {
43672       result = (Dali::Path *)new Dali::Path();
43673     } catch (std::out_of_range& e) {
43674       {
43675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43676       };
43677     } catch (std::exception& e) {
43678       {
43679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43680       };
43681     } catch (Dali::DaliException e) {
43682       {
43683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43684       };
43685     } catch (...) {
43686       {
43687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43688       };
43689     }
43690   }
43691
43692   jresult = (void *)result;
43693   return jresult;
43694 }
43695
43696
43697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43698   Dali::Path *arg1 = (Dali::Path *) 0 ;
43699
43700   arg1 = (Dali::Path *)jarg1;
43701   {
43702     try {
43703       delete arg1;
43704     } catch (std::out_of_range& e) {
43705       {
43706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43707       };
43708     } catch (std::exception& e) {
43709       {
43710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43711       };
43712     } catch (Dali::DaliException e) {
43713       {
43714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43715       };
43716     } catch (...) {
43717       {
43718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43719       };
43720     }
43721   }
43722
43723 }
43724
43725
43726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43727   void * jresult ;
43728   Dali::Path *arg1 = 0 ;
43729   Dali::Path *result = 0 ;
43730
43731   arg1 = (Dali::Path *)jarg1;
43732   if (!arg1) {
43733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43734     return 0;
43735   }
43736   {
43737     try {
43738       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43739     } catch (std::out_of_range& e) {
43740       {
43741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43742       };
43743     } catch (std::exception& e) {
43744       {
43745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43746       };
43747     } catch (Dali::DaliException e) {
43748       {
43749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43750       };
43751     } catch (...) {
43752       {
43753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43754       };
43755     }
43756   }
43757
43758   jresult = (void *)result;
43759   return jresult;
43760 }
43761
43762
43763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43764   void * jresult ;
43765   Dali::Path *arg1 = (Dali::Path *) 0 ;
43766   Dali::Path *arg2 = 0 ;
43767   Dali::Path *result = 0 ;
43768
43769   arg1 = (Dali::Path *)jarg1;
43770   arg2 = (Dali::Path *)jarg2;
43771   if (!arg2) {
43772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43773     return 0;
43774   }
43775   {
43776     try {
43777       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43778     } catch (std::out_of_range& e) {
43779       {
43780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43781       };
43782     } catch (std::exception& e) {
43783       {
43784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43785       };
43786     } catch (Dali::DaliException e) {
43787       {
43788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43789       };
43790     } catch (...) {
43791       {
43792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43793       };
43794     }
43795   }
43796
43797   jresult = (void *)result;
43798   return jresult;
43799 }
43800
43801
43802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43803   Dali::Path *arg1 = (Dali::Path *) 0 ;
43804   Dali::Vector3 *arg2 = 0 ;
43805
43806   arg1 = (Dali::Path *)jarg1;
43807   arg2 = (Dali::Vector3 *)jarg2;
43808   if (!arg2) {
43809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43810     return ;
43811   }
43812   {
43813     try {
43814       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43815     } catch (std::out_of_range& e) {
43816       {
43817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43818       };
43819     } catch (std::exception& e) {
43820       {
43821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43822       };
43823     } catch (Dali::DaliException e) {
43824       {
43825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43826       };
43827     } catch (...) {
43828       {
43829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43830       };
43831     }
43832   }
43833
43834 }
43835
43836
43837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43838   Dali::Path *arg1 = (Dali::Path *) 0 ;
43839   Dali::Vector3 *arg2 = 0 ;
43840
43841   arg1 = (Dali::Path *)jarg1;
43842   arg2 = (Dali::Vector3 *)jarg2;
43843   if (!arg2) {
43844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43845     return ;
43846   }
43847   {
43848     try {
43849       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43850     } catch (std::out_of_range& e) {
43851       {
43852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43853       };
43854     } catch (std::exception& e) {
43855       {
43856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43857       };
43858     } catch (Dali::DaliException e) {
43859       {
43860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43861       };
43862     } catch (...) {
43863       {
43864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43865       };
43866     }
43867   }
43868
43869 }
43870
43871
43872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43873   Dali::Path *arg1 = (Dali::Path *) 0 ;
43874   float arg2 ;
43875
43876   arg1 = (Dali::Path *)jarg1;
43877   arg2 = (float)jarg2;
43878   {
43879     try {
43880       (arg1)->GenerateControlPoints(arg2);
43881     } catch (std::out_of_range& e) {
43882       {
43883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43884       };
43885     } catch (std::exception& e) {
43886       {
43887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43888       };
43889     } catch (Dali::DaliException e) {
43890       {
43891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43892       };
43893     } catch (...) {
43894       {
43895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43896       };
43897     }
43898   }
43899
43900 }
43901
43902
43903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43904   Dali::Path *arg1 = (Dali::Path *) 0 ;
43905   float arg2 ;
43906   Dali::Vector3 *arg3 = 0 ;
43907   Dali::Vector3 *arg4 = 0 ;
43908
43909   arg1 = (Dali::Path *)jarg1;
43910   arg2 = (float)jarg2;
43911   arg3 = (Dali::Vector3 *)jarg3;
43912   if (!arg3) {
43913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43914     return ;
43915   }
43916   arg4 = (Dali::Vector3 *)jarg4;
43917   if (!arg4) {
43918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43919     return ;
43920   }
43921   {
43922     try {
43923       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43924     } catch (std::out_of_range& e) {
43925       {
43926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43927       };
43928     } catch (std::exception& e) {
43929       {
43930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43931       };
43932     } catch (Dali::DaliException e) {
43933       {
43934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43935       };
43936     } catch (...) {
43937       {
43938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43939       };
43940     }
43941   }
43942
43943 }
43944
43945
43946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43947   void * jresult ;
43948   Dali::Path *arg1 = (Dali::Path *) 0 ;
43949   size_t arg2 ;
43950   Dali::Vector3 *result = 0 ;
43951
43952   arg1 = (Dali::Path *)jarg1;
43953   arg2 = (size_t)jarg2;
43954   {
43955     try {
43956       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43957     } catch (std::out_of_range& e) {
43958       {
43959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43960       };
43961     } catch (std::exception& e) {
43962       {
43963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43964       };
43965     } catch (Dali::DaliException e) {
43966       {
43967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43968       };
43969     } catch (...) {
43970       {
43971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43972       };
43973     }
43974   }
43975
43976   jresult = (void *)result;
43977   return jresult;
43978 }
43979
43980
43981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43982   void * jresult ;
43983   Dali::Path *arg1 = (Dali::Path *) 0 ;
43984   size_t arg2 ;
43985   Dali::Vector3 *result = 0 ;
43986
43987   arg1 = (Dali::Path *)jarg1;
43988   arg2 = (size_t)jarg2;
43989   {
43990     try {
43991       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43992     } catch (std::out_of_range& e) {
43993       {
43994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43995       };
43996     } catch (std::exception& e) {
43997       {
43998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43999       };
44000     } catch (Dali::DaliException e) {
44001       {
44002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44003       };
44004     } catch (...) {
44005       {
44006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44007       };
44008     }
44009   }
44010
44011   jresult = (void *)result;
44012   return jresult;
44013 }
44014
44015
44016 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44017   unsigned long jresult ;
44018   Dali::Path *arg1 = (Dali::Path *) 0 ;
44019   size_t result;
44020
44021   arg1 = (Dali::Path *)jarg1;
44022   {
44023     try {
44024       result = ((Dali::Path const *)arg1)->GetPointCount();
44025     } catch (std::out_of_range& e) {
44026       {
44027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44028       };
44029     } catch (std::exception& e) {
44030       {
44031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44032       };
44033     } catch (Dali::DaliException e) {
44034       {
44035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44036       };
44037     } catch (...) {
44038       {
44039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44040       };
44041     }
44042   }
44043
44044   jresult = (unsigned long)result;
44045   return jresult;
44046 }
44047
44048
44049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44050   void * jresult ;
44051   float arg1 ;
44052   Dali::TimePeriod *result = 0 ;
44053
44054   arg1 = (float)jarg1;
44055   {
44056     try {
44057       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44058     } catch (std::out_of_range& e) {
44059       {
44060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44061       };
44062     } catch (std::exception& e) {
44063       {
44064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44065       };
44066     } catch (Dali::DaliException e) {
44067       {
44068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44069       };
44070     } catch (...) {
44071       {
44072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44073       };
44074     }
44075   }
44076
44077   jresult = (void *)result;
44078   return jresult;
44079 }
44080
44081
44082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44083   void * jresult ;
44084   float arg1 ;
44085   float arg2 ;
44086   Dali::TimePeriod *result = 0 ;
44087
44088   arg1 = (float)jarg1;
44089   arg2 = (float)jarg2;
44090   {
44091     try {
44092       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44093     } catch (std::out_of_range& e) {
44094       {
44095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44096       };
44097     } catch (std::exception& e) {
44098       {
44099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44100       };
44101     } catch (Dali::DaliException e) {
44102       {
44103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44104       };
44105     } catch (...) {
44106       {
44107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44108       };
44109     }
44110   }
44111
44112   jresult = (void *)result;
44113   return jresult;
44114 }
44115
44116
44117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44118   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44119
44120   arg1 = (Dali::TimePeriod *)jarg1;
44121   {
44122     try {
44123       delete arg1;
44124     } catch (std::out_of_range& e) {
44125       {
44126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44127       };
44128     } catch (std::exception& e) {
44129       {
44130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44131       };
44132     } catch (Dali::DaliException e) {
44133       {
44134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44135       };
44136     } catch (...) {
44137       {
44138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44139       };
44140     }
44141   }
44142
44143 }
44144
44145
44146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44147   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44148   float arg2 ;
44149
44150   arg1 = (Dali::TimePeriod *)jarg1;
44151   arg2 = (float)jarg2;
44152   if (arg1) (arg1)->delaySeconds = arg2;
44153 }
44154
44155
44156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44157   float jresult ;
44158   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44159   float result;
44160
44161   arg1 = (Dali::TimePeriod *)jarg1;
44162   result = (float) ((arg1)->delaySeconds);
44163   jresult = result;
44164   return jresult;
44165 }
44166
44167
44168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44169   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44170   float arg2 ;
44171
44172   arg1 = (Dali::TimePeriod *)jarg1;
44173   arg2 = (float)jarg2;
44174   if (arg1) (arg1)->durationSeconds = arg2;
44175 }
44176
44177
44178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44179   float jresult ;
44180   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44181   float result;
44182
44183   arg1 = (Dali::TimePeriod *)jarg1;
44184   result = (float) ((arg1)->durationSeconds);
44185   jresult = result;
44186   return jresult;
44187 }
44188
44189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44190   int jresult ;
44191   int result;
44192
44193   result = (int)Dali::LinearConstrainer::Property::VALUE;
44194   jresult = (int)result;
44195   return jresult;
44196 }
44197
44198
44199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44200   int jresult ;
44201   int result;
44202
44203   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44204   jresult = (int)result;
44205   return jresult;
44206 }
44207
44208
44209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44210   void * jresult ;
44211   Dali::LinearConstrainer::Property *result = 0 ;
44212
44213   {
44214     try {
44215       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44216     } catch (std::out_of_range& e) {
44217       {
44218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44219       };
44220     } catch (std::exception& e) {
44221       {
44222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44223       };
44224     } catch (Dali::DaliException e) {
44225       {
44226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44227       };
44228     } catch (...) {
44229       {
44230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44231       };
44232     }
44233   }
44234
44235   jresult = (void *)result;
44236   return jresult;
44237 }
44238
44239
44240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44241   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44242
44243   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44244   {
44245     try {
44246       delete arg1;
44247     } catch (std::out_of_range& e) {
44248       {
44249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44250       };
44251     } catch (std::exception& e) {
44252       {
44253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44254       };
44255     } catch (Dali::DaliException e) {
44256       {
44257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44258       };
44259     } catch (...) {
44260       {
44261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44262       };
44263     }
44264   }
44265
44266 }
44267
44268
44269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44270   void * jresult ;
44271   Dali::LinearConstrainer result;
44272
44273   {
44274     try {
44275       result = Dali::LinearConstrainer::New();
44276     } catch (std::out_of_range& e) {
44277       {
44278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44279       };
44280     } catch (std::exception& e) {
44281       {
44282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44283       };
44284     } catch (Dali::DaliException e) {
44285       {
44286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44287       };
44288     } catch (...) {
44289       {
44290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44291       };
44292     }
44293   }
44294
44295   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44296   return jresult;
44297 }
44298
44299
44300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44301   void * jresult ;
44302   Dali::BaseHandle arg1 ;
44303   Dali::BaseHandle *argp1 ;
44304   Dali::LinearConstrainer result;
44305
44306   argp1 = (Dali::BaseHandle *)jarg1;
44307   if (!argp1) {
44308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44309     return 0;
44310   }
44311   arg1 = *argp1;
44312   {
44313     try {
44314       result = Dali::LinearConstrainer::DownCast(arg1);
44315     } catch (std::out_of_range& e) {
44316       {
44317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44318       };
44319     } catch (std::exception& e) {
44320       {
44321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44322       };
44323     } catch (Dali::DaliException e) {
44324       {
44325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44326       };
44327     } catch (...) {
44328       {
44329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44330       };
44331     }
44332   }
44333
44334   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44335   return jresult;
44336 }
44337
44338
44339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44340   void * jresult ;
44341   Dali::LinearConstrainer *result = 0 ;
44342
44343   {
44344     try {
44345       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44346     } catch (std::out_of_range& e) {
44347       {
44348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44349       };
44350     } catch (std::exception& e) {
44351       {
44352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44353       };
44354     } catch (Dali::DaliException e) {
44355       {
44356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44357       };
44358     } catch (...) {
44359       {
44360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44361       };
44362     }
44363   }
44364
44365   jresult = (void *)result;
44366   return jresult;
44367 }
44368
44369
44370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44371   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44372
44373   arg1 = (Dali::LinearConstrainer *)jarg1;
44374   {
44375     try {
44376       delete arg1;
44377     } catch (std::out_of_range& e) {
44378       {
44379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44380       };
44381     } catch (std::exception& e) {
44382       {
44383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44384       };
44385     } catch (Dali::DaliException e) {
44386       {
44387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44388       };
44389     } catch (...) {
44390       {
44391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44392       };
44393     }
44394   }
44395
44396 }
44397
44398
44399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44400   void * jresult ;
44401   Dali::LinearConstrainer *arg1 = 0 ;
44402   Dali::LinearConstrainer *result = 0 ;
44403
44404   arg1 = (Dali::LinearConstrainer *)jarg1;
44405   if (!arg1) {
44406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44407     return 0;
44408   }
44409   {
44410     try {
44411       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44412     } catch (std::out_of_range& e) {
44413       {
44414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44415       };
44416     } catch (std::exception& e) {
44417       {
44418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44419       };
44420     } catch (Dali::DaliException e) {
44421       {
44422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44423       };
44424     } catch (...) {
44425       {
44426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44427       };
44428     }
44429   }
44430
44431   jresult = (void *)result;
44432   return jresult;
44433 }
44434
44435
44436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44437   void * jresult ;
44438   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44439   Dali::LinearConstrainer *arg2 = 0 ;
44440   Dali::LinearConstrainer *result = 0 ;
44441
44442   arg1 = (Dali::LinearConstrainer *)jarg1;
44443   arg2 = (Dali::LinearConstrainer *)jarg2;
44444   if (!arg2) {
44445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44446     return 0;
44447   }
44448   {
44449     try {
44450       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44451     } catch (std::out_of_range& e) {
44452       {
44453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44454       };
44455     } catch (std::exception& e) {
44456       {
44457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44458       };
44459     } catch (Dali::DaliException e) {
44460       {
44461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44462       };
44463     } catch (...) {
44464       {
44465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44466       };
44467     }
44468   }
44469
44470   jresult = (void *)result;
44471   return jresult;
44472 }
44473
44474
44475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44476   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44477   SwigValueWrapper< Dali::Property > arg2 ;
44478   SwigValueWrapper< Dali::Property > arg3 ;
44479   Dali::Vector2 *arg4 = 0 ;
44480   Dali::Vector2 *arg5 = 0 ;
44481   Dali::Property *argp2 ;
44482   Dali::Property *argp3 ;
44483
44484   arg1 = (Dali::LinearConstrainer *)jarg1;
44485   argp2 = (Dali::Property *)jarg2;
44486   if (!argp2) {
44487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44488     return ;
44489   }
44490   arg2 = *argp2;
44491   argp3 = (Dali::Property *)jarg3;
44492   if (!argp3) {
44493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44494     return ;
44495   }
44496   arg3 = *argp3;
44497   arg4 = (Dali::Vector2 *)jarg4;
44498   if (!arg4) {
44499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44500     return ;
44501   }
44502   arg5 = (Dali::Vector2 *)jarg5;
44503   if (!arg5) {
44504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44505     return ;
44506   }
44507   {
44508     try {
44509       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44510     } catch (std::out_of_range& e) {
44511       {
44512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44513       };
44514     } catch (std::exception& e) {
44515       {
44516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44517       };
44518     } catch (Dali::DaliException e) {
44519       {
44520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44521       };
44522     } catch (...) {
44523       {
44524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44525       };
44526     }
44527   }
44528
44529 }
44530
44531
44532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44533   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44534   SwigValueWrapper< Dali::Property > arg2 ;
44535   SwigValueWrapper< Dali::Property > arg3 ;
44536   Dali::Vector2 *arg4 = 0 ;
44537   Dali::Property *argp2 ;
44538   Dali::Property *argp3 ;
44539
44540   arg1 = (Dali::LinearConstrainer *)jarg1;
44541   argp2 = (Dali::Property *)jarg2;
44542   if (!argp2) {
44543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44544     return ;
44545   }
44546   arg2 = *argp2;
44547   argp3 = (Dali::Property *)jarg3;
44548   if (!argp3) {
44549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44550     return ;
44551   }
44552   arg3 = *argp3;
44553   arg4 = (Dali::Vector2 *)jarg4;
44554   if (!arg4) {
44555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44556     return ;
44557   }
44558   {
44559     try {
44560       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44561     } catch (std::out_of_range& e) {
44562       {
44563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44564       };
44565     } catch (std::exception& e) {
44566       {
44567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44568       };
44569     } catch (Dali::DaliException e) {
44570       {
44571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44572       };
44573     } catch (...) {
44574       {
44575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44576       };
44577     }
44578   }
44579
44580 }
44581
44582
44583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44584   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44585   Dali::Handle *arg2 = 0 ;
44586
44587   arg1 = (Dali::LinearConstrainer *)jarg1;
44588   arg2 = (Dali::Handle *)jarg2;
44589   if (!arg2) {
44590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44591     return ;
44592   }
44593   {
44594     try {
44595       (arg1)->Remove(*arg2);
44596     } catch (std::out_of_range& e) {
44597       {
44598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44599       };
44600     } catch (std::exception& e) {
44601       {
44602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44603       };
44604     } catch (Dali::DaliException e) {
44605       {
44606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44607       };
44608     } catch (...) {
44609       {
44610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44611       };
44612     }
44613   }
44614
44615 }
44616
44617
44618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44619   int jresult ;
44620   int result;
44621
44622   result = (int)Dali::PathConstrainer::Property::FORWARD;
44623   jresult = (int)result;
44624   return jresult;
44625 }
44626
44627
44628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44629   int jresult ;
44630   int result;
44631
44632   result = (int)Dali::PathConstrainer::Property::POINTS;
44633   jresult = (int)result;
44634   return jresult;
44635 }
44636
44637
44638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44639   int jresult ;
44640   int result;
44641
44642   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44643   jresult = (int)result;
44644   return jresult;
44645 }
44646
44647
44648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44649   void * jresult ;
44650   Dali::PathConstrainer::Property *result = 0 ;
44651
44652   {
44653     try {
44654       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44655     } catch (std::out_of_range& e) {
44656       {
44657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44658       };
44659     } catch (std::exception& e) {
44660       {
44661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44662       };
44663     } catch (Dali::DaliException e) {
44664       {
44665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44666       };
44667     } catch (...) {
44668       {
44669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44670       };
44671     }
44672   }
44673
44674   jresult = (void *)result;
44675   return jresult;
44676 }
44677
44678
44679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44680   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44681
44682   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44683   {
44684     try {
44685       delete arg1;
44686     } catch (std::out_of_range& e) {
44687       {
44688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44689       };
44690     } catch (std::exception& e) {
44691       {
44692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44693       };
44694     } catch (Dali::DaliException e) {
44695       {
44696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44697       };
44698     } catch (...) {
44699       {
44700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44701       };
44702     }
44703   }
44704
44705 }
44706
44707
44708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44709   void * jresult ;
44710   Dali::PathConstrainer result;
44711
44712   {
44713     try {
44714       result = Dali::PathConstrainer::New();
44715     } catch (std::out_of_range& e) {
44716       {
44717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44718       };
44719     } catch (std::exception& e) {
44720       {
44721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44722       };
44723     } catch (Dali::DaliException e) {
44724       {
44725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44726       };
44727     } catch (...) {
44728       {
44729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44730       };
44731     }
44732   }
44733
44734   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44735   return jresult;
44736 }
44737
44738
44739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44740   void * jresult ;
44741   Dali::BaseHandle arg1 ;
44742   Dali::BaseHandle *argp1 ;
44743   Dali::PathConstrainer result;
44744
44745   argp1 = (Dali::BaseHandle *)jarg1;
44746   if (!argp1) {
44747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44748     return 0;
44749   }
44750   arg1 = *argp1;
44751   {
44752     try {
44753       result = Dali::PathConstrainer::DownCast(arg1);
44754     } catch (std::out_of_range& e) {
44755       {
44756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44757       };
44758     } catch (std::exception& e) {
44759       {
44760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44761       };
44762     } catch (Dali::DaliException e) {
44763       {
44764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44765       };
44766     } catch (...) {
44767       {
44768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44769       };
44770     }
44771   }
44772
44773   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44774   return jresult;
44775 }
44776
44777
44778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44779   void * jresult ;
44780   Dali::PathConstrainer *result = 0 ;
44781
44782   {
44783     try {
44784       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44785     } catch (std::out_of_range& e) {
44786       {
44787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44788       };
44789     } catch (std::exception& e) {
44790       {
44791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44792       };
44793     } catch (Dali::DaliException e) {
44794       {
44795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44796       };
44797     } catch (...) {
44798       {
44799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44800       };
44801     }
44802   }
44803
44804   jresult = (void *)result;
44805   return jresult;
44806 }
44807
44808
44809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44810   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44811
44812   arg1 = (Dali::PathConstrainer *)jarg1;
44813   {
44814     try {
44815       delete arg1;
44816     } catch (std::out_of_range& e) {
44817       {
44818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44819       };
44820     } catch (std::exception& e) {
44821       {
44822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44823       };
44824     } catch (Dali::DaliException e) {
44825       {
44826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44827       };
44828     } catch (...) {
44829       {
44830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44831       };
44832     }
44833   }
44834
44835 }
44836
44837
44838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44839   void * jresult ;
44840   Dali::PathConstrainer *arg1 = 0 ;
44841   Dali::PathConstrainer *result = 0 ;
44842
44843   arg1 = (Dali::PathConstrainer *)jarg1;
44844   if (!arg1) {
44845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44846     return 0;
44847   }
44848   {
44849     try {
44850       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44851     } catch (std::out_of_range& e) {
44852       {
44853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44854       };
44855     } catch (std::exception& e) {
44856       {
44857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44858       };
44859     } catch (Dali::DaliException e) {
44860       {
44861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44862       };
44863     } catch (...) {
44864       {
44865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44866       };
44867     }
44868   }
44869
44870   jresult = (void *)result;
44871   return jresult;
44872 }
44873
44874
44875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44876   void * jresult ;
44877   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44878   Dali::PathConstrainer *arg2 = 0 ;
44879   Dali::PathConstrainer *result = 0 ;
44880
44881   arg1 = (Dali::PathConstrainer *)jarg1;
44882   arg2 = (Dali::PathConstrainer *)jarg2;
44883   if (!arg2) {
44884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44885     return 0;
44886   }
44887   {
44888     try {
44889       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44890     } catch (std::out_of_range& e) {
44891       {
44892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44893       };
44894     } catch (std::exception& e) {
44895       {
44896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44897       };
44898     } catch (Dali::DaliException e) {
44899       {
44900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44901       };
44902     } catch (...) {
44903       {
44904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44905       };
44906     }
44907   }
44908
44909   jresult = (void *)result;
44910   return jresult;
44911 }
44912
44913
44914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44915   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44916   SwigValueWrapper< Dali::Property > arg2 ;
44917   SwigValueWrapper< Dali::Property > arg3 ;
44918   Dali::Vector2 *arg4 = 0 ;
44919   Dali::Vector2 *arg5 = 0 ;
44920   Dali::Property *argp2 ;
44921   Dali::Property *argp3 ;
44922
44923   arg1 = (Dali::PathConstrainer *)jarg1;
44924   argp2 = (Dali::Property *)jarg2;
44925   if (!argp2) {
44926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44927     return ;
44928   }
44929   arg2 = *argp2;
44930   argp3 = (Dali::Property *)jarg3;
44931   if (!argp3) {
44932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44933     return ;
44934   }
44935   arg3 = *argp3;
44936   arg4 = (Dali::Vector2 *)jarg4;
44937   if (!arg4) {
44938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44939     return ;
44940   }
44941   arg5 = (Dali::Vector2 *)jarg5;
44942   if (!arg5) {
44943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44944     return ;
44945   }
44946   {
44947     try {
44948       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44949     } catch (std::out_of_range& e) {
44950       {
44951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44952       };
44953     } catch (std::exception& e) {
44954       {
44955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44956       };
44957     } catch (Dali::DaliException e) {
44958       {
44959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44960       };
44961     } catch (...) {
44962       {
44963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44964       };
44965     }
44966   }
44967
44968 }
44969
44970
44971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44972   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44973   SwigValueWrapper< Dali::Property > arg2 ;
44974   SwigValueWrapper< Dali::Property > arg3 ;
44975   Dali::Vector2 *arg4 = 0 ;
44976   Dali::Property *argp2 ;
44977   Dali::Property *argp3 ;
44978
44979   arg1 = (Dali::PathConstrainer *)jarg1;
44980   argp2 = (Dali::Property *)jarg2;
44981   if (!argp2) {
44982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44983     return ;
44984   }
44985   arg2 = *argp2;
44986   argp3 = (Dali::Property *)jarg3;
44987   if (!argp3) {
44988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44989     return ;
44990   }
44991   arg3 = *argp3;
44992   arg4 = (Dali::Vector2 *)jarg4;
44993   if (!arg4) {
44994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44995     return ;
44996   }
44997   {
44998     try {
44999       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45000     } catch (std::out_of_range& e) {
45001       {
45002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45003       };
45004     } catch (std::exception& e) {
45005       {
45006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45007       };
45008     } catch (Dali::DaliException e) {
45009       {
45010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45011       };
45012     } catch (...) {
45013       {
45014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45015       };
45016     }
45017   }
45018
45019 }
45020
45021
45022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45023   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45024   Dali::Handle *arg2 = 0 ;
45025
45026   arg1 = (Dali::PathConstrainer *)jarg1;
45027   arg2 = (Dali::Handle *)jarg2;
45028   if (!arg2) {
45029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45030     return ;
45031   }
45032   {
45033     try {
45034       (arg1)->Remove(*arg2);
45035     } catch (std::out_of_range& e) {
45036       {
45037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45038       };
45039     } catch (std::exception& e) {
45040       {
45041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45042       };
45043     } catch (Dali::DaliException e) {
45044       {
45045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45046       };
45047     } catch (...) {
45048       {
45049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45050       };
45051     }
45052   }
45053
45054 }
45055
45056
45057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45058   int jresult ;
45059   Dali::FittingMode::Type result;
45060
45061   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45062   jresult = (int)result;
45063   return jresult;
45064 }
45065
45066
45067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45068   int jresult ;
45069   Dali::SamplingMode::Type result;
45070
45071   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45072   jresult = (int)result;
45073   return jresult;
45074 }
45075
45076
45077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
45078   void * jresult ;
45079   Dali::BufferImage *result = 0 ;
45080
45081   {
45082     try {
45083       result = (Dali::BufferImage *)new Dali::BufferImage();
45084     } catch (std::out_of_range& e) {
45085       {
45086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45087       };
45088     } catch (std::exception& e) {
45089       {
45090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45091       };
45092     } catch (Dali::DaliException e) {
45093       {
45094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45095       };
45096     } catch (...) {
45097       {
45098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45099       };
45100     }
45101   }
45102
45103   jresult = (void *)result;
45104   return jresult;
45105 }
45106
45107
45108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45109   void * jresult ;
45110   unsigned int arg1 ;
45111   unsigned int arg2 ;
45112   Dali::Pixel::Format arg3 ;
45113   Dali::BufferImage result;
45114
45115   arg1 = (unsigned int)jarg1;
45116   arg2 = (unsigned int)jarg2;
45117   arg3 = (Dali::Pixel::Format)jarg3;
45118   {
45119     try {
45120       result = Dali::BufferImage::New(arg1,arg2,arg3);
45121     } catch (std::out_of_range& e) {
45122       {
45123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45124       };
45125     } catch (std::exception& e) {
45126       {
45127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45128       };
45129     } catch (Dali::DaliException e) {
45130       {
45131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45132       };
45133     } catch (...) {
45134       {
45135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45136       };
45137     }
45138   }
45139
45140   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45141   return jresult;
45142 }
45143
45144
45145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45146   void * jresult ;
45147   unsigned int arg1 ;
45148   unsigned int arg2 ;
45149   Dali::BufferImage result;
45150
45151   arg1 = (unsigned int)jarg1;
45152   arg2 = (unsigned int)jarg2;
45153   {
45154     try {
45155       result = Dali::BufferImage::New(arg1,arg2);
45156     } catch (std::out_of_range& e) {
45157       {
45158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45159       };
45160     } catch (std::exception& e) {
45161       {
45162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45163       };
45164     } catch (Dali::DaliException e) {
45165       {
45166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45167       };
45168     } catch (...) {
45169       {
45170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45171       };
45172     }
45173   }
45174
45175   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45176   return jresult;
45177 }
45178
45179
45180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45181   void * jresult ;
45182   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45183   unsigned int arg2 ;
45184   unsigned int arg3 ;
45185   Dali::Pixel::Format arg4 ;
45186   unsigned int arg5 ;
45187   Dali::BufferImage result;
45188
45189   arg1 = jarg1;
45190   arg2 = (unsigned int)jarg2;
45191   arg3 = (unsigned int)jarg3;
45192   arg4 = (Dali::Pixel::Format)jarg4;
45193   arg5 = (unsigned int)jarg5;
45194   {
45195     try {
45196       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45197     } catch (std::out_of_range& e) {
45198       {
45199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45200       };
45201     } catch (std::exception& e) {
45202       {
45203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45204       };
45205     } catch (Dali::DaliException e) {
45206       {
45207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45208       };
45209     } catch (...) {
45210       {
45211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45212       };
45213     }
45214   }
45215
45216   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45217
45218
45219   return jresult;
45220 }
45221
45222
45223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45224   void * jresult ;
45225   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45226   unsigned int arg2 ;
45227   unsigned int arg3 ;
45228   Dali::Pixel::Format arg4 ;
45229   Dali::BufferImage result;
45230
45231   arg1 = jarg1;
45232   arg2 = (unsigned int)jarg2;
45233   arg3 = (unsigned int)jarg3;
45234   arg4 = (Dali::Pixel::Format)jarg4;
45235   {
45236     try {
45237       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45238     } catch (std::out_of_range& e) {
45239       {
45240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45241       };
45242     } catch (std::exception& e) {
45243       {
45244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45245       };
45246     } catch (Dali::DaliException e) {
45247       {
45248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45249       };
45250     } catch (...) {
45251       {
45252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45253       };
45254     }
45255   }
45256
45257   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45258
45259
45260   return jresult;
45261 }
45262
45263
45264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45265   void * jresult ;
45266   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45267   unsigned int arg2 ;
45268   unsigned int arg3 ;
45269   Dali::BufferImage result;
45270
45271   arg1 = jarg1;
45272   arg2 = (unsigned int)jarg2;
45273   arg3 = (unsigned int)jarg3;
45274   {
45275     try {
45276       result = Dali::BufferImage::New(arg1,arg2,arg3);
45277     } catch (std::out_of_range& e) {
45278       {
45279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45280       };
45281     } catch (std::exception& e) {
45282       {
45283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45284       };
45285     } catch (Dali::DaliException e) {
45286       {
45287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45288       };
45289     } catch (...) {
45290       {
45291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45292       };
45293     }
45294   }
45295
45296   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45297
45298
45299   return jresult;
45300 }
45301
45302
45303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45304   void * jresult ;
45305   Dali::BaseHandle arg1 ;
45306   Dali::BaseHandle *argp1 ;
45307   Dali::BufferImage result;
45308
45309   argp1 = (Dali::BaseHandle *)jarg1;
45310   if (!argp1) {
45311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45312     return 0;
45313   }
45314   arg1 = *argp1;
45315   {
45316     try {
45317       result = Dali::BufferImage::DownCast(arg1);
45318     } catch (std::out_of_range& e) {
45319       {
45320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45321       };
45322     } catch (std::exception& e) {
45323       {
45324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45325       };
45326     } catch (Dali::DaliException e) {
45327       {
45328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45329       };
45330     } catch (...) {
45331       {
45332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45333       };
45334     }
45335   }
45336
45337   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45338   return jresult;
45339 }
45340
45341
45342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45343   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45344
45345   arg1 = (Dali::BufferImage *)jarg1;
45346   {
45347     try {
45348       delete arg1;
45349     } catch (std::out_of_range& e) {
45350       {
45351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45352       };
45353     } catch (std::exception& e) {
45354       {
45355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45356       };
45357     } catch (Dali::DaliException e) {
45358       {
45359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45360       };
45361     } catch (...) {
45362       {
45363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45364       };
45365     }
45366   }
45367
45368 }
45369
45370
45371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45372   void * jresult ;
45373   Dali::BufferImage *arg1 = 0 ;
45374   Dali::BufferImage *result = 0 ;
45375
45376   arg1 = (Dali::BufferImage *)jarg1;
45377   if (!arg1) {
45378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45379     return 0;
45380   }
45381   {
45382     try {
45383       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45384     } catch (std::out_of_range& e) {
45385       {
45386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45387       };
45388     } catch (std::exception& e) {
45389       {
45390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45391       };
45392     } catch (Dali::DaliException e) {
45393       {
45394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45395       };
45396     } catch (...) {
45397       {
45398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45399       };
45400     }
45401   }
45402
45403   jresult = (void *)result;
45404   return jresult;
45405 }
45406
45407
45408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45409   void * jresult ;
45410   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45411   Dali::BufferImage *arg2 = 0 ;
45412   Dali::BufferImage *result = 0 ;
45413
45414   arg1 = (Dali::BufferImage *)jarg1;
45415   arg2 = (Dali::BufferImage *)jarg2;
45416   if (!arg2) {
45417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45418     return 0;
45419   }
45420   {
45421     try {
45422       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45423     } catch (std::out_of_range& e) {
45424       {
45425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45426       };
45427     } catch (std::exception& e) {
45428       {
45429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45430       };
45431     } catch (Dali::DaliException e) {
45432       {
45433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45434       };
45435     } catch (...) {
45436       {
45437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45438       };
45439     }
45440   }
45441
45442   jresult = (void *)result;
45443   return jresult;
45444 }
45445
45446
45447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45448   void * jresult ;
45449   Dali::BufferImage result;
45450
45451   {
45452     try {
45453       result = Dali::BufferImage::WHITE();
45454     } catch (std::out_of_range& e) {
45455       {
45456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45457       };
45458     } catch (std::exception& e) {
45459       {
45460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45461       };
45462     } catch (Dali::DaliException e) {
45463       {
45464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45465       };
45466     } catch (...) {
45467       {
45468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45469       };
45470     }
45471   }
45472
45473   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45474   return jresult;
45475 }
45476
45477
45478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45479   void * jresult ;
45480   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45481   Dali::PixelBuffer *result = 0 ;
45482
45483   arg1 = (Dali::BufferImage *)jarg1;
45484   {
45485     try {
45486       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45487     } catch (std::out_of_range& e) {
45488       {
45489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45490       };
45491     } catch (std::exception& e) {
45492       {
45493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45494       };
45495     } catch (Dali::DaliException e) {
45496       {
45497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45498       };
45499     } catch (...) {
45500       {
45501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45502       };
45503     }
45504   }
45505
45506   jresult = (void *)result;
45507   return jresult;
45508 }
45509
45510
45511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45512   unsigned int jresult ;
45513   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45514   unsigned int result;
45515
45516   arg1 = (Dali::BufferImage *)jarg1;
45517   {
45518     try {
45519       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45520     } catch (std::out_of_range& e) {
45521       {
45522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45523       };
45524     } catch (std::exception& e) {
45525       {
45526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45527       };
45528     } catch (Dali::DaliException e) {
45529       {
45530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45531       };
45532     } catch (...) {
45533       {
45534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45535       };
45536     }
45537   }
45538
45539   jresult = result;
45540   return jresult;
45541 }
45542
45543
45544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45545   unsigned int jresult ;
45546   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45547   unsigned int result;
45548
45549   arg1 = (Dali::BufferImage *)jarg1;
45550   {
45551     try {
45552       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45553     } catch (std::out_of_range& e) {
45554       {
45555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45556       };
45557     } catch (std::exception& e) {
45558       {
45559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45560       };
45561     } catch (Dali::DaliException e) {
45562       {
45563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45564       };
45565     } catch (...) {
45566       {
45567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45568       };
45569     }
45570   }
45571
45572   jresult = result;
45573   return jresult;
45574 }
45575
45576
45577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45578   int jresult ;
45579   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45580   Dali::Pixel::Format result;
45581
45582   arg1 = (Dali::BufferImage *)jarg1;
45583   {
45584     try {
45585       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45586     } catch (std::out_of_range& e) {
45587       {
45588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45589       };
45590     } catch (std::exception& e) {
45591       {
45592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45593       };
45594     } catch (Dali::DaliException e) {
45595       {
45596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45597       };
45598     } catch (...) {
45599       {
45600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45601       };
45602     }
45603   }
45604
45605   jresult = (int)result;
45606   return jresult;
45607 }
45608
45609
45610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45611   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45612
45613   arg1 = (Dali::BufferImage *)jarg1;
45614   {
45615     try {
45616       (arg1)->Update();
45617     } catch (std::out_of_range& e) {
45618       {
45619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45620       };
45621     } catch (std::exception& e) {
45622       {
45623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45624       };
45625     } catch (Dali::DaliException e) {
45626       {
45627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45628       };
45629     } catch (...) {
45630       {
45631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45632       };
45633     }
45634   }
45635
45636 }
45637
45638
45639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45640   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45641   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45642   Dali::RectArea *argp2 ;
45643
45644   arg1 = (Dali::BufferImage *)jarg1;
45645   argp2 = (Dali::RectArea *)jarg2;
45646   if (!argp2) {
45647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45648     return ;
45649   }
45650   arg2 = *argp2;
45651   {
45652     try {
45653       (arg1)->Update(arg2);
45654     } catch (std::out_of_range& e) {
45655       {
45656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45657       };
45658     } catch (std::exception& e) {
45659       {
45660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45661       };
45662     } catch (Dali::DaliException e) {
45663       {
45664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45665       };
45666     } catch (...) {
45667       {
45668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45669       };
45670     }
45671   }
45672
45673 }
45674
45675
45676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45677   unsigned int jresult ;
45678   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45679   bool result;
45680
45681   arg1 = (Dali::BufferImage *)jarg1;
45682   {
45683     try {
45684       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45685     } catch (std::out_of_range& e) {
45686       {
45687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45688       };
45689     } catch (std::exception& e) {
45690       {
45691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45692       };
45693     } catch (Dali::DaliException e) {
45694       {
45695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45696       };
45697     } catch (...) {
45698       {
45699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45700       };
45701     }
45702   }
45703
45704   jresult = result;
45705   return jresult;
45706 }
45707
45708
45709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45710   void * jresult ;
45711   Dali::EncodedBufferImage *result = 0 ;
45712
45713   {
45714     try {
45715       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45716     } catch (std::out_of_range& e) {
45717       {
45718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45719       };
45720     } catch (std::exception& e) {
45721       {
45722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45723       };
45724     } catch (Dali::DaliException e) {
45725       {
45726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45727       };
45728     } catch (...) {
45729       {
45730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45731       };
45732     }
45733   }
45734
45735   jresult = (void *)result;
45736   return jresult;
45737 }
45738
45739
45740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45741   void * jresult ;
45742   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45743   std::size_t arg2 ;
45744   Dali::EncodedBufferImage result;
45745
45746   arg1 = (uint8_t *)jarg1;
45747   arg2 = (std::size_t)jarg2;
45748   {
45749     try {
45750       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45751     } catch (std::out_of_range& e) {
45752       {
45753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45754       };
45755     } catch (std::exception& e) {
45756       {
45757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45758       };
45759     } catch (Dali::DaliException e) {
45760       {
45761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45762       };
45763     } catch (...) {
45764       {
45765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45766       };
45767     }
45768   }
45769
45770   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45771   return jresult;
45772 }
45773
45774
45775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45776   void * jresult ;
45777   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45778   std::size_t arg2 ;
45779   Dali::ImageDimensions arg3 ;
45780   Dali::FittingMode::Type arg4 ;
45781   Dali::SamplingMode::Type arg5 ;
45782   bool arg6 ;
45783   Dali::ImageDimensions *argp3 ;
45784   Dali::EncodedBufferImage result;
45785
45786   arg1 = (uint8_t *)jarg1;
45787   arg2 = (std::size_t)jarg2;
45788   argp3 = (Dali::ImageDimensions *)jarg3;
45789   if (!argp3) {
45790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45791     return 0;
45792   }
45793   arg3 = *argp3;
45794   arg4 = (Dali::FittingMode::Type)jarg4;
45795   arg5 = (Dali::SamplingMode::Type)jarg5;
45796   arg6 = jarg6 ? true : false;
45797   {
45798     try {
45799       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45800     } catch (std::out_of_range& e) {
45801       {
45802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45803       };
45804     } catch (std::exception& e) {
45805       {
45806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45807       };
45808     } catch (Dali::DaliException e) {
45809       {
45810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45811       };
45812     } catch (...) {
45813       {
45814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45815       };
45816     }
45817   }
45818
45819   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45820   return jresult;
45821 }
45822
45823
45824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45825   void * jresult ;
45826   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45827   std::size_t arg2 ;
45828   Dali::ImageDimensions arg3 ;
45829   Dali::FittingMode::Type arg4 ;
45830   Dali::SamplingMode::Type arg5 ;
45831   Dali::ImageDimensions *argp3 ;
45832   Dali::EncodedBufferImage result;
45833
45834   arg1 = (uint8_t *)jarg1;
45835   arg2 = (std::size_t)jarg2;
45836   argp3 = (Dali::ImageDimensions *)jarg3;
45837   if (!argp3) {
45838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45839     return 0;
45840   }
45841   arg3 = *argp3;
45842   arg4 = (Dali::FittingMode::Type)jarg4;
45843   arg5 = (Dali::SamplingMode::Type)jarg5;
45844   {
45845     try {
45846       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45847     } catch (std::out_of_range& e) {
45848       {
45849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45850       };
45851     } catch (std::exception& e) {
45852       {
45853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45854       };
45855     } catch (Dali::DaliException e) {
45856       {
45857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45858       };
45859     } catch (...) {
45860       {
45861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45862       };
45863     }
45864   }
45865
45866   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45867   return jresult;
45868 }
45869
45870
45871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45872   void * jresult ;
45873   Dali::BaseHandle arg1 ;
45874   Dali::BaseHandle *argp1 ;
45875   Dali::EncodedBufferImage result;
45876
45877   argp1 = (Dali::BaseHandle *)jarg1;
45878   if (!argp1) {
45879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45880     return 0;
45881   }
45882   arg1 = *argp1;
45883   {
45884     try {
45885       result = Dali::EncodedBufferImage::DownCast(arg1);
45886     } catch (std::out_of_range& e) {
45887       {
45888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45889       };
45890     } catch (std::exception& e) {
45891       {
45892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45893       };
45894     } catch (Dali::DaliException e) {
45895       {
45896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45897       };
45898     } catch (...) {
45899       {
45900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45901       };
45902     }
45903   }
45904
45905   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45906   return jresult;
45907 }
45908
45909
45910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45911   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45912
45913   arg1 = (Dali::EncodedBufferImage *)jarg1;
45914   {
45915     try {
45916       delete arg1;
45917     } catch (std::out_of_range& e) {
45918       {
45919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45920       };
45921     } catch (std::exception& e) {
45922       {
45923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45924       };
45925     } catch (Dali::DaliException e) {
45926       {
45927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45928       };
45929     } catch (...) {
45930       {
45931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45932       };
45933     }
45934   }
45935
45936 }
45937
45938
45939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45940   void * jresult ;
45941   Dali::EncodedBufferImage *arg1 = 0 ;
45942   Dali::EncodedBufferImage *result = 0 ;
45943
45944   arg1 = (Dali::EncodedBufferImage *)jarg1;
45945   if (!arg1) {
45946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45947     return 0;
45948   }
45949   {
45950     try {
45951       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45952     } catch (std::out_of_range& e) {
45953       {
45954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45955       };
45956     } catch (std::exception& e) {
45957       {
45958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45959       };
45960     } catch (Dali::DaliException e) {
45961       {
45962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45963       };
45964     } catch (...) {
45965       {
45966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45967       };
45968     }
45969   }
45970
45971   jresult = (void *)result;
45972   return jresult;
45973 }
45974
45975
45976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45977   void * jresult ;
45978   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45979   Dali::EncodedBufferImage *arg2 = 0 ;
45980   Dali::EncodedBufferImage *result = 0 ;
45981
45982   arg1 = (Dali::EncodedBufferImage *)jarg1;
45983   arg2 = (Dali::EncodedBufferImage *)jarg2;
45984   if (!arg2) {
45985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45986     return 0;
45987   }
45988   {
45989     try {
45990       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45991     } catch (std::out_of_range& e) {
45992       {
45993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45994       };
45995     } catch (std::exception& e) {
45996       {
45997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45998       };
45999     } catch (Dali::DaliException e) {
46000       {
46001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46002       };
46003     } catch (...) {
46004       {
46005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46006       };
46007     }
46008   }
46009
46010   jresult = (void *)result;
46011   return jresult;
46012 }
46013
46014
46015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
46016   void * jresult ;
46017   Dali::NativeImage *result = 0 ;
46018
46019   {
46020     try {
46021       result = (Dali::NativeImage *)new Dali::NativeImage();
46022     } catch (std::out_of_range& e) {
46023       {
46024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46025       };
46026     } catch (std::exception& e) {
46027       {
46028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46029       };
46030     } catch (Dali::DaliException e) {
46031       {
46032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46033       };
46034     } catch (...) {
46035       {
46036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46037       };
46038     }
46039   }
46040
46041   jresult = (void *)result;
46042   return jresult;
46043 }
46044
46045
46046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
46047   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46048
46049   arg1 = (Dali::NativeImage *)jarg1;
46050   {
46051     try {
46052       delete arg1;
46053     } catch (std::out_of_range& e) {
46054       {
46055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46056       };
46057     } catch (std::exception& e) {
46058       {
46059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46060       };
46061     } catch (Dali::DaliException e) {
46062       {
46063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46064       };
46065     } catch (...) {
46066       {
46067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46068       };
46069     }
46070   }
46071
46072 }
46073
46074
46075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
46076   void * jresult ;
46077   Dali::NativeImage *arg1 = 0 ;
46078   Dali::NativeImage *result = 0 ;
46079
46080   arg1 = (Dali::NativeImage *)jarg1;
46081   if (!arg1) {
46082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46083     return 0;
46084   }
46085   {
46086     try {
46087       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46088     } catch (std::out_of_range& e) {
46089       {
46090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46091       };
46092     } catch (std::exception& e) {
46093       {
46094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46095       };
46096     } catch (Dali::DaliException e) {
46097       {
46098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46099       };
46100     } catch (...) {
46101       {
46102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46103       };
46104     }
46105   }
46106
46107   jresult = (void *)result;
46108   return jresult;
46109 }
46110
46111
46112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46113   void * jresult ;
46114   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46115   Dali::NativeImage *arg2 = 0 ;
46116   Dali::NativeImage *result = 0 ;
46117
46118   arg1 = (Dali::NativeImage *)jarg1;
46119   arg2 = (Dali::NativeImage *)jarg2;
46120   if (!arg2) {
46121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46122     return 0;
46123   }
46124   {
46125     try {
46126       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46127     } catch (std::out_of_range& e) {
46128       {
46129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46130       };
46131     } catch (std::exception& e) {
46132       {
46133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46134       };
46135     } catch (Dali::DaliException e) {
46136       {
46137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46138       };
46139     } catch (...) {
46140       {
46141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46142       };
46143     }
46144   }
46145
46146   jresult = (void *)result;
46147   return jresult;
46148 }
46149
46150
46151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46152   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46153
46154   arg1 = (Dali::NativeImage *)jarg1;
46155   {
46156     try {
46157       (arg1)->CreateGlTexture();
46158     } catch (std::out_of_range& e) {
46159       {
46160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46161       };
46162     } catch (std::exception& e) {
46163       {
46164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46165       };
46166     } catch (Dali::DaliException e) {
46167       {
46168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46169       };
46170     } catch (...) {
46171       {
46172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46173       };
46174     }
46175   }
46176
46177 }
46178
46179
46180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46181   void * jresult ;
46182   NativeImageInterface *arg1 = 0 ;
46183   Dali::NativeImage result;
46184
46185   arg1 = (NativeImageInterface *)jarg1;
46186   if (!arg1) {
46187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46188     return 0;
46189   }
46190   {
46191     try {
46192       result = Dali::NativeImage::New(*arg1);
46193     } catch (std::out_of_range& e) {
46194       {
46195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46196       };
46197     } catch (std::exception& e) {
46198       {
46199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46200       };
46201     } catch (Dali::DaliException e) {
46202       {
46203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46204       };
46205     } catch (...) {
46206       {
46207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46208       };
46209     }
46210   }
46211
46212   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46213   return jresult;
46214 }
46215
46216
46217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46218   void * jresult ;
46219   Dali::BaseHandle arg1 ;
46220   Dali::BaseHandle *argp1 ;
46221   Dali::NativeImage result;
46222
46223   argp1 = (Dali::BaseHandle *)jarg1;
46224   if (!argp1) {
46225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46226     return 0;
46227   }
46228   arg1 = *argp1;
46229   {
46230     try {
46231       result = Dali::NativeImage::DownCast(arg1);
46232     } catch (std::out_of_range& e) {
46233       {
46234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46235       };
46236     } catch (std::exception& e) {
46237       {
46238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46239       };
46240     } catch (Dali::DaliException e) {
46241       {
46242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46243       };
46244     } catch (...) {
46245       {
46246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46247       };
46248     }
46249   }
46250
46251   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46252   return jresult;
46253 }
46254
46255
46256 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46257   char * jresult ;
46258   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46259   char *result = 0 ;
46260
46261   arg1 = (Dali::NativeImage *)jarg1;
46262   {
46263     try {
46264       result = (char *)(arg1)->GetCustomFragmentPreFix();
46265     } catch (std::out_of_range& e) {
46266       {
46267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46268       };
46269     } catch (std::exception& e) {
46270       {
46271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46272       };
46273     } catch (Dali::DaliException e) {
46274       {
46275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46276       };
46277     } catch (...) {
46278       {
46279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46280       };
46281     }
46282   }
46283
46284   jresult = SWIG_csharp_string_callback((const char *)result);
46285   return jresult;
46286 }
46287
46288
46289 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46290   char * jresult ;
46291   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46292   char *result = 0 ;
46293
46294   arg1 = (Dali::NativeImage *)jarg1;
46295   {
46296     try {
46297       result = (char *)(arg1)->GetCustomSamplerTypename();
46298     } catch (std::out_of_range& e) {
46299       {
46300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46301       };
46302     } catch (std::exception& e) {
46303       {
46304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46305       };
46306     } catch (Dali::DaliException e) {
46307       {
46308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46309       };
46310     } catch (...) {
46311       {
46312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46313       };
46314     }
46315   }
46316
46317   jresult = SWIG_csharp_string_callback((const char *)result);
46318   return jresult;
46319 }
46320
46321
46322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46323   unsigned int jresult ;
46324   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46325   bool result;
46326
46327   arg1 = (Dali::NativeImageInterface *)jarg1;
46328   {
46329     try {
46330       result = (bool)(arg1)->GlExtensionCreate();
46331     } catch (std::out_of_range& e) {
46332       {
46333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46334       };
46335     } catch (std::exception& e) {
46336       {
46337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46338       };
46339     } catch (Dali::DaliException e) {
46340       {
46341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46342       };
46343     } catch (...) {
46344       {
46345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46346       };
46347     }
46348   }
46349
46350   jresult = result;
46351   return jresult;
46352 }
46353
46354
46355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46356   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46357
46358   arg1 = (Dali::NativeImageInterface *)jarg1;
46359   {
46360     try {
46361       (arg1)->GlExtensionDestroy();
46362     } catch (std::out_of_range& e) {
46363       {
46364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46365       };
46366     } catch (std::exception& e) {
46367       {
46368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46369       };
46370     } catch (Dali::DaliException e) {
46371       {
46372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46373       };
46374     } catch (...) {
46375       {
46376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46377       };
46378     }
46379   }
46380
46381 }
46382
46383
46384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46385   unsigned int jresult ;
46386   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46387   unsigned int result;
46388
46389   arg1 = (Dali::NativeImageInterface *)jarg1;
46390   {
46391     try {
46392       result = (unsigned int)(arg1)->TargetTexture();
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 = result;
46413   return jresult;
46414 }
46415
46416
46417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46418   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46419
46420   arg1 = (Dali::NativeImageInterface *)jarg1;
46421   {
46422     try {
46423       (arg1)->PrepareTexture();
46424     } catch (std::out_of_range& e) {
46425       {
46426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46427       };
46428     } catch (std::exception& e) {
46429       {
46430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46431       };
46432     } catch (Dali::DaliException e) {
46433       {
46434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46435       };
46436     } catch (...) {
46437       {
46438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46439       };
46440     }
46441   }
46442
46443 }
46444
46445
46446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46447   unsigned int jresult ;
46448   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46449   unsigned int result;
46450
46451   arg1 = (Dali::NativeImageInterface *)jarg1;
46452   {
46453     try {
46454       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46455     } catch (std::out_of_range& e) {
46456       {
46457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46458       };
46459     } catch (std::exception& e) {
46460       {
46461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46462       };
46463     } catch (Dali::DaliException e) {
46464       {
46465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46466       };
46467     } catch (...) {
46468       {
46469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46470       };
46471     }
46472   }
46473
46474   jresult = result;
46475   return jresult;
46476 }
46477
46478
46479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46480   unsigned int jresult ;
46481   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46482   unsigned int result;
46483
46484   arg1 = (Dali::NativeImageInterface *)jarg1;
46485   {
46486     try {
46487       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46488     } catch (std::out_of_range& e) {
46489       {
46490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46491       };
46492     } catch (std::exception& e) {
46493       {
46494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46495       };
46496     } catch (Dali::DaliException e) {
46497       {
46498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46499       };
46500     } catch (...) {
46501       {
46502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46503       };
46504     }
46505   }
46506
46507   jresult = result;
46508   return jresult;
46509 }
46510
46511
46512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46513   unsigned int jresult ;
46514   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46515   bool result;
46516
46517   arg1 = (Dali::NativeImageInterface *)jarg1;
46518   {
46519     try {
46520       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46521     } catch (std::out_of_range& e) {
46522       {
46523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46524       };
46525     } catch (std::exception& e) {
46526       {
46527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46528       };
46529     } catch (Dali::DaliException e) {
46530       {
46531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46532       };
46533     } catch (...) {
46534       {
46535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46536       };
46537     }
46538   }
46539
46540   jresult = result;
46541   return jresult;
46542 }
46543
46544
46545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46546   void * jresult ;
46547   std::string *arg1 = 0 ;
46548   Dali::ImageDimensions result;
46549
46550   if (!jarg1) {
46551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46552     return 0;
46553   }
46554   std::string arg1_str(jarg1);
46555   arg1 = &arg1_str;
46556   {
46557     try {
46558       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46559     } catch (std::out_of_range& e) {
46560       {
46561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46562       };
46563     } catch (std::exception& e) {
46564       {
46565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46566       };
46567     } catch (Dali::DaliException e) {
46568       {
46569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46570       };
46571     } catch (...) {
46572       {
46573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46574       };
46575     }
46576   }
46577
46578   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46579
46580   //argout typemap for const std::string&
46581
46582   return jresult;
46583 }
46584
46585
46586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46587   void * jresult ;
46588   Dali::ResourceImage *result = 0 ;
46589
46590   {
46591     try {
46592       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46593     } catch (std::out_of_range& e) {
46594       {
46595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46596       };
46597     } catch (std::exception& e) {
46598       {
46599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46600       };
46601     } catch (Dali::DaliException e) {
46602       {
46603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46604       };
46605     } catch (...) {
46606       {
46607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46608       };
46609     }
46610   }
46611
46612   jresult = (void *)result;
46613   return jresult;
46614 }
46615
46616
46617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46618   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46619
46620   arg1 = (Dali::ResourceImage *)jarg1;
46621   {
46622     try {
46623       delete arg1;
46624     } catch (std::out_of_range& e) {
46625       {
46626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46627       };
46628     } catch (std::exception& e) {
46629       {
46630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46631       };
46632     } catch (Dali::DaliException e) {
46633       {
46634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46635       };
46636     } catch (...) {
46637       {
46638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46639       };
46640     }
46641   }
46642
46643 }
46644
46645
46646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46647   void * jresult ;
46648   Dali::ResourceImage *arg1 = 0 ;
46649   Dali::ResourceImage *result = 0 ;
46650
46651   arg1 = (Dali::ResourceImage *)jarg1;
46652   if (!arg1) {
46653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46654     return 0;
46655   }
46656   {
46657     try {
46658       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46659     } catch (std::out_of_range& e) {
46660       {
46661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46662       };
46663     } catch (std::exception& e) {
46664       {
46665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46666       };
46667     } catch (Dali::DaliException e) {
46668       {
46669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46670       };
46671     } catch (...) {
46672       {
46673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46674       };
46675     }
46676   }
46677
46678   jresult = (void *)result;
46679   return jresult;
46680 }
46681
46682
46683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46684   void * jresult ;
46685   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46686   Dali::ResourceImage *arg2 = 0 ;
46687   Dali::ResourceImage *result = 0 ;
46688
46689   arg1 = (Dali::ResourceImage *)jarg1;
46690   arg2 = (Dali::ResourceImage *)jarg2;
46691   if (!arg2) {
46692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46693     return 0;
46694   }
46695   {
46696     try {
46697       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46698     } catch (std::out_of_range& e) {
46699       {
46700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46701       };
46702     } catch (std::exception& e) {
46703       {
46704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46705       };
46706     } catch (Dali::DaliException e) {
46707       {
46708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46709       };
46710     } catch (...) {
46711       {
46712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46713       };
46714     }
46715   }
46716
46717   jresult = (void *)result;
46718   return jresult;
46719 }
46720
46721
46722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46723   void * jresult ;
46724   std::string *arg1 = 0 ;
46725   bool arg2 ;
46726   Dali::ResourceImage result;
46727
46728   if (!jarg1) {
46729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46730     return 0;
46731   }
46732   std::string arg1_str(jarg1);
46733   arg1 = &arg1_str;
46734   arg2 = jarg2 ? true : false;
46735   {
46736     try {
46737       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46738     } catch (std::out_of_range& e) {
46739       {
46740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46741       };
46742     } catch (std::exception& e) {
46743       {
46744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46745       };
46746     } catch (Dali::DaliException e) {
46747       {
46748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46749       };
46750     } catch (...) {
46751       {
46752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46753       };
46754     }
46755   }
46756
46757   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46758
46759   //argout typemap for const std::string&
46760
46761   return jresult;
46762 }
46763
46764
46765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46766   void * jresult ;
46767   std::string *arg1 = 0 ;
46768   Dali::ResourceImage result;
46769
46770   if (!jarg1) {
46771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46772     return 0;
46773   }
46774   std::string arg1_str(jarg1);
46775   arg1 = &arg1_str;
46776   {
46777     try {
46778       result = Dali::ResourceImage::New((std::string const &)*arg1);
46779     } catch (std::out_of_range& e) {
46780       {
46781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46782       };
46783     } catch (std::exception& e) {
46784       {
46785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46786       };
46787     } catch (Dali::DaliException e) {
46788       {
46789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46790       };
46791     } catch (...) {
46792       {
46793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46794       };
46795     }
46796   }
46797
46798   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46799
46800   //argout typemap for const std::string&
46801
46802   return jresult;
46803 }
46804
46805
46806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46807   void * jresult ;
46808   std::string *arg1 = 0 ;
46809   Dali::ImageDimensions arg2 ;
46810   Dali::FittingMode::Type arg3 ;
46811   Dali::SamplingMode::Type arg4 ;
46812   bool arg5 ;
46813   Dali::ImageDimensions *argp2 ;
46814   Dali::ResourceImage result;
46815
46816   if (!jarg1) {
46817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46818     return 0;
46819   }
46820   std::string arg1_str(jarg1);
46821   arg1 = &arg1_str;
46822   argp2 = (Dali::ImageDimensions *)jarg2;
46823   if (!argp2) {
46824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46825     return 0;
46826   }
46827   arg2 = *argp2;
46828   arg3 = (Dali::FittingMode::Type)jarg3;
46829   arg4 = (Dali::SamplingMode::Type)jarg4;
46830   arg5 = jarg5 ? true : false;
46831   {
46832     try {
46833       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46834     } catch (std::out_of_range& e) {
46835       {
46836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46837       };
46838     } catch (std::exception& e) {
46839       {
46840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46841       };
46842     } catch (Dali::DaliException e) {
46843       {
46844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46845       };
46846     } catch (...) {
46847       {
46848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46849       };
46850     }
46851   }
46852
46853   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46854
46855   //argout typemap for const std::string&
46856
46857   return jresult;
46858 }
46859
46860
46861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46862   void * jresult ;
46863   std::string *arg1 = 0 ;
46864   Dali::ImageDimensions arg2 ;
46865   Dali::FittingMode::Type arg3 ;
46866   Dali::SamplingMode::Type arg4 ;
46867   Dali::ImageDimensions *argp2 ;
46868   Dali::ResourceImage result;
46869
46870   if (!jarg1) {
46871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46872     return 0;
46873   }
46874   std::string arg1_str(jarg1);
46875   arg1 = &arg1_str;
46876   argp2 = (Dali::ImageDimensions *)jarg2;
46877   if (!argp2) {
46878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46879     return 0;
46880   }
46881   arg2 = *argp2;
46882   arg3 = (Dali::FittingMode::Type)jarg3;
46883   arg4 = (Dali::SamplingMode::Type)jarg4;
46884   {
46885     try {
46886       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46887     } catch (std::out_of_range& e) {
46888       {
46889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46890       };
46891     } catch (std::exception& e) {
46892       {
46893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46894       };
46895     } catch (Dali::DaliException e) {
46896       {
46897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46898       };
46899     } catch (...) {
46900       {
46901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46902       };
46903     }
46904   }
46905
46906   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46907
46908   //argout typemap for const std::string&
46909
46910   return jresult;
46911 }
46912
46913
46914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46915   void * jresult ;
46916   std::string *arg1 = 0 ;
46917   Dali::ImageDimensions arg2 ;
46918   Dali::FittingMode::Type arg3 ;
46919   Dali::ImageDimensions *argp2 ;
46920   Dali::ResourceImage result;
46921
46922   if (!jarg1) {
46923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46924     return 0;
46925   }
46926   std::string arg1_str(jarg1);
46927   arg1 = &arg1_str;
46928   argp2 = (Dali::ImageDimensions *)jarg2;
46929   if (!argp2) {
46930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46931     return 0;
46932   }
46933   arg2 = *argp2;
46934   arg3 = (Dali::FittingMode::Type)jarg3;
46935   {
46936     try {
46937       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46938     } catch (std::out_of_range& e) {
46939       {
46940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46941       };
46942     } catch (std::exception& e) {
46943       {
46944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46945       };
46946     } catch (Dali::DaliException e) {
46947       {
46948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46949       };
46950     } catch (...) {
46951       {
46952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46953       };
46954     }
46955   }
46956
46957   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46958
46959   //argout typemap for const std::string&
46960
46961   return jresult;
46962 }
46963
46964
46965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46966   void * jresult ;
46967   std::string *arg1 = 0 ;
46968   Dali::ImageDimensions arg2 ;
46969   Dali::ImageDimensions *argp2 ;
46970   Dali::ResourceImage result;
46971
46972   if (!jarg1) {
46973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46974     return 0;
46975   }
46976   std::string arg1_str(jarg1);
46977   arg1 = &arg1_str;
46978   argp2 = (Dali::ImageDimensions *)jarg2;
46979   if (!argp2) {
46980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46981     return 0;
46982   }
46983   arg2 = *argp2;
46984   {
46985     try {
46986       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46987     } catch (std::out_of_range& e) {
46988       {
46989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46990       };
46991     } catch (std::exception& e) {
46992       {
46993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46994       };
46995     } catch (Dali::DaliException e) {
46996       {
46997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46998       };
46999     } catch (...) {
47000       {
47001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47002       };
47003     }
47004   }
47005
47006   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47007
47008   //argout typemap for const std::string&
47009
47010   return jresult;
47011 }
47012
47013
47014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
47015   void * jresult ;
47016   Dali::BaseHandle arg1 ;
47017   Dali::BaseHandle *argp1 ;
47018   Dali::ResourceImage result;
47019
47020   argp1 = (Dali::BaseHandle *)jarg1;
47021   if (!argp1) {
47022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47023     return 0;
47024   }
47025   arg1 = *argp1;
47026   {
47027     try {
47028       result = Dali::ResourceImage::DownCast(arg1);
47029     } catch (std::out_of_range& e) {
47030       {
47031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47032       };
47033     } catch (std::exception& e) {
47034       {
47035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47036       };
47037     } catch (Dali::DaliException e) {
47038       {
47039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47040       };
47041     } catch (...) {
47042       {
47043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47044       };
47045     }
47046   }
47047
47048   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
47049   return jresult;
47050 }
47051
47052
47053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
47054   int jresult ;
47055   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47056   Dali::LoadingState result;
47057
47058   arg1 = (Dali::ResourceImage *)jarg1;
47059   {
47060     try {
47061       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
47062     } catch (std::out_of_range& e) {
47063       {
47064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47065       };
47066     } catch (std::exception& e) {
47067       {
47068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47069       };
47070     } catch (Dali::DaliException e) {
47071       {
47072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47073       };
47074     } catch (...) {
47075       {
47076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47077       };
47078     }
47079   }
47080
47081   jresult = (int)result;
47082   return jresult;
47083 }
47084
47085
47086 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47087   char * jresult ;
47088   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47089   std::string result;
47090
47091   arg1 = (Dali::ResourceImage *)jarg1;
47092   {
47093     try {
47094       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47095     } catch (std::out_of_range& e) {
47096       {
47097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47098       };
47099     } catch (std::exception& e) {
47100       {
47101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47102       };
47103     } catch (Dali::DaliException e) {
47104       {
47105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47106       };
47107     } catch (...) {
47108       {
47109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47110       };
47111     }
47112   }
47113
47114   jresult = SWIG_csharp_string_callback((&result)->c_str());
47115   return jresult;
47116 }
47117
47118
47119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47120   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47121
47122   arg1 = (Dali::ResourceImage *)jarg1;
47123   {
47124     try {
47125       (arg1)->Reload();
47126     } catch (std::out_of_range& e) {
47127       {
47128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47129       };
47130     } catch (std::exception& e) {
47131       {
47132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47133       };
47134     } catch (Dali::DaliException e) {
47135       {
47136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47137       };
47138     } catch (...) {
47139       {
47140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47141       };
47142     }
47143   }
47144
47145 }
47146
47147
47148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47149   void * jresult ;
47150   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47151   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47152
47153   arg1 = (Dali::ResourceImage *)jarg1;
47154   {
47155     try {
47156       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47157     } catch (std::out_of_range& e) {
47158       {
47159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47160       };
47161     } catch (std::exception& e) {
47162       {
47163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47164       };
47165     } catch (Dali::DaliException e) {
47166       {
47167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47168       };
47169     } catch (...) {
47170       {
47171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47172       };
47173     }
47174   }
47175
47176   jresult = (void *)result;
47177   return jresult;
47178 }
47179
47180
47181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47182   void * jresult ;
47183   Dali::FrameBufferImage *result = 0 ;
47184
47185   {
47186     try {
47187       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47188     } catch (std::out_of_range& e) {
47189       {
47190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47191       };
47192     } catch (std::exception& e) {
47193       {
47194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47195       };
47196     } catch (Dali::DaliException e) {
47197       {
47198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47199       };
47200     } catch (...) {
47201       {
47202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47203       };
47204     }
47205   }
47206
47207   jresult = (void *)result;
47208   return jresult;
47209 }
47210
47211
47212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47213   void * jresult ;
47214   unsigned int arg1 ;
47215   unsigned int arg2 ;
47216   Dali::Pixel::Format arg3 ;
47217   Dali::RenderBuffer::Format arg4 ;
47218   Dali::FrameBufferImage result;
47219
47220   arg1 = (unsigned int)jarg1;
47221   arg2 = (unsigned int)jarg2;
47222   arg3 = (Dali::Pixel::Format)jarg3;
47223   arg4 = (Dali::RenderBuffer::Format)jarg4;
47224   {
47225     try {
47226       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47227     } catch (std::out_of_range& e) {
47228       {
47229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47230       };
47231     } catch (std::exception& e) {
47232       {
47233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47234       };
47235     } catch (Dali::DaliException e) {
47236       {
47237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47238       };
47239     } catch (...) {
47240       {
47241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47242       };
47243     }
47244   }
47245
47246   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47247   return jresult;
47248 }
47249
47250
47251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47252   void * jresult ;
47253   unsigned int arg1 ;
47254   unsigned int arg2 ;
47255   Dali::Pixel::Format arg3 ;
47256   Dali::FrameBufferImage result;
47257
47258   arg1 = (unsigned int)jarg1;
47259   arg2 = (unsigned int)jarg2;
47260   arg3 = (Dali::Pixel::Format)jarg3;
47261   {
47262     try {
47263       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47264     } catch (std::out_of_range& e) {
47265       {
47266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47267       };
47268     } catch (std::exception& e) {
47269       {
47270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47271       };
47272     } catch (Dali::DaliException e) {
47273       {
47274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47275       };
47276     } catch (...) {
47277       {
47278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47279       };
47280     }
47281   }
47282
47283   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47284   return jresult;
47285 }
47286
47287
47288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47289   void * jresult ;
47290   unsigned int arg1 ;
47291   unsigned int arg2 ;
47292   Dali::FrameBufferImage result;
47293
47294   arg1 = (unsigned int)jarg1;
47295   arg2 = (unsigned int)jarg2;
47296   {
47297     try {
47298       result = Dali::FrameBufferImage::New(arg1,arg2);
47299     } catch (std::out_of_range& e) {
47300       {
47301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47302       };
47303     } catch (std::exception& e) {
47304       {
47305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47306       };
47307     } catch (Dali::DaliException e) {
47308       {
47309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47310       };
47311     } catch (...) {
47312       {
47313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47314       };
47315     }
47316   }
47317
47318   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47319   return jresult;
47320 }
47321
47322
47323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47324   void * jresult ;
47325   unsigned int arg1 ;
47326   Dali::FrameBufferImage result;
47327
47328   arg1 = (unsigned int)jarg1;
47329   {
47330     try {
47331       result = Dali::FrameBufferImage::New(arg1);
47332     } catch (std::out_of_range& e) {
47333       {
47334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47335       };
47336     } catch (std::exception& e) {
47337       {
47338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47339       };
47340     } catch (Dali::DaliException e) {
47341       {
47342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47343       };
47344     } catch (...) {
47345       {
47346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47347       };
47348     }
47349   }
47350
47351   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47352   return jresult;
47353 }
47354
47355
47356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47357   void * jresult ;
47358   Dali::FrameBufferImage result;
47359
47360   {
47361     try {
47362       result = Dali::FrameBufferImage::New();
47363     } catch (std::out_of_range& e) {
47364       {
47365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47366       };
47367     } catch (std::exception& e) {
47368       {
47369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47370       };
47371     } catch (Dali::DaliException e) {
47372       {
47373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47374       };
47375     } catch (...) {
47376       {
47377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47378       };
47379     }
47380   }
47381
47382   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47383   return jresult;
47384 }
47385
47386
47387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47388   void * jresult ;
47389   Dali::NativeImageInterface *arg1 = 0 ;
47390   Dali::FrameBufferImage result;
47391
47392   arg1 = (Dali::NativeImageInterface *)jarg1;
47393   if (!arg1) {
47394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47395     return 0;
47396   }
47397   {
47398     try {
47399       result = Dali::FrameBufferImage::New(*arg1);
47400     } catch (std::out_of_range& e) {
47401       {
47402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47403       };
47404     } catch (std::exception& e) {
47405       {
47406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47407       };
47408     } catch (Dali::DaliException e) {
47409       {
47410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47411       };
47412     } catch (...) {
47413       {
47414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47415       };
47416     }
47417   }
47418
47419   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47420   return jresult;
47421 }
47422
47423
47424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47425   void * jresult ;
47426   Dali::BaseHandle arg1 ;
47427   Dali::BaseHandle *argp1 ;
47428   Dali::FrameBufferImage result;
47429
47430   argp1 = (Dali::BaseHandle *)jarg1;
47431   if (!argp1) {
47432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47433     return 0;
47434   }
47435   arg1 = *argp1;
47436   {
47437     try {
47438       result = Dali::FrameBufferImage::DownCast(arg1);
47439     } catch (std::out_of_range& e) {
47440       {
47441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47442       };
47443     } catch (std::exception& e) {
47444       {
47445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47446       };
47447     } catch (Dali::DaliException e) {
47448       {
47449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47450       };
47451     } catch (...) {
47452       {
47453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47454       };
47455     }
47456   }
47457
47458   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47459   return jresult;
47460 }
47461
47462
47463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47464   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47465
47466   arg1 = (Dali::FrameBufferImage *)jarg1;
47467   {
47468     try {
47469       delete arg1;
47470     } catch (std::out_of_range& e) {
47471       {
47472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47473       };
47474     } catch (std::exception& e) {
47475       {
47476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47477       };
47478     } catch (Dali::DaliException e) {
47479       {
47480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47481       };
47482     } catch (...) {
47483       {
47484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47485       };
47486     }
47487   }
47488
47489 }
47490
47491
47492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47493   void * jresult ;
47494   Dali::FrameBufferImage *arg1 = 0 ;
47495   Dali::FrameBufferImage *result = 0 ;
47496
47497   arg1 = (Dali::FrameBufferImage *)jarg1;
47498   if (!arg1) {
47499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47500     return 0;
47501   }
47502   {
47503     try {
47504       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47505     } catch (std::out_of_range& e) {
47506       {
47507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47508       };
47509     } catch (std::exception& e) {
47510       {
47511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47512       };
47513     } catch (Dali::DaliException e) {
47514       {
47515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47516       };
47517     } catch (...) {
47518       {
47519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47520       };
47521     }
47522   }
47523
47524   jresult = (void *)result;
47525   return jresult;
47526 }
47527
47528
47529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47530   void * jresult ;
47531   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47532   Dali::FrameBufferImage *arg2 = 0 ;
47533   Dali::FrameBufferImage *result = 0 ;
47534
47535   arg1 = (Dali::FrameBufferImage *)jarg1;
47536   arg2 = (Dali::FrameBufferImage *)jarg2;
47537   if (!arg2) {
47538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47539     return 0;
47540   }
47541   {
47542     try {
47543       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47544     } catch (std::out_of_range& e) {
47545       {
47546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47547       };
47548     } catch (std::exception& e) {
47549       {
47550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47551       };
47552     } catch (Dali::DaliException e) {
47553       {
47554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47555       };
47556     } catch (...) {
47557       {
47558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47559       };
47560     }
47561   }
47562
47563   jresult = (void *)result;
47564   return jresult;
47565 }
47566
47567
47568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47569   void * jresult ;
47570   Dali::NinePatchImage *result = 0 ;
47571
47572   {
47573     try {
47574       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47575     } catch (std::out_of_range& e) {
47576       {
47577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47578       };
47579     } catch (std::exception& e) {
47580       {
47581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47582       };
47583     } catch (Dali::DaliException e) {
47584       {
47585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47586       };
47587     } catch (...) {
47588       {
47589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47590       };
47591     }
47592   }
47593
47594   jresult = (void *)result;
47595   return jresult;
47596 }
47597
47598
47599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47600   void * jresult ;
47601   std::string *arg1 = 0 ;
47602   Dali::NinePatchImage result;
47603
47604   if (!jarg1) {
47605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47606     return 0;
47607   }
47608   std::string arg1_str(jarg1);
47609   arg1 = &arg1_str;
47610   {
47611     try {
47612       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47613     } catch (std::out_of_range& e) {
47614       {
47615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47616       };
47617     } catch (std::exception& e) {
47618       {
47619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47620       };
47621     } catch (Dali::DaliException e) {
47622       {
47623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47624       };
47625     } catch (...) {
47626       {
47627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47628       };
47629     }
47630   }
47631
47632   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47633
47634   //argout typemap for const std::string&
47635
47636   return jresult;
47637 }
47638
47639
47640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47641   void * jresult ;
47642   Dali::BaseHandle arg1 ;
47643   Dali::BaseHandle *argp1 ;
47644   Dali::NinePatchImage result;
47645
47646   argp1 = (Dali::BaseHandle *)jarg1;
47647   if (!argp1) {
47648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47649     return 0;
47650   }
47651   arg1 = *argp1;
47652   {
47653     try {
47654       result = Dali::NinePatchImage::DownCast(arg1);
47655     } catch (std::out_of_range& e) {
47656       {
47657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47658       };
47659     } catch (std::exception& e) {
47660       {
47661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47662       };
47663     } catch (Dali::DaliException e) {
47664       {
47665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47666       };
47667     } catch (...) {
47668       {
47669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47670       };
47671     }
47672   }
47673
47674   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47675   return jresult;
47676 }
47677
47678
47679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47680   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47681
47682   arg1 = (Dali::NinePatchImage *)jarg1;
47683   {
47684     try {
47685       delete arg1;
47686     } catch (std::out_of_range& e) {
47687       {
47688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47689       };
47690     } catch (std::exception& e) {
47691       {
47692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47693       };
47694     } catch (Dali::DaliException e) {
47695       {
47696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47697       };
47698     } catch (...) {
47699       {
47700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47701       };
47702     }
47703   }
47704
47705 }
47706
47707
47708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47709   void * jresult ;
47710   Dali::NinePatchImage *arg1 = 0 ;
47711   Dali::NinePatchImage *result = 0 ;
47712
47713   arg1 = (Dali::NinePatchImage *)jarg1;
47714   if (!arg1) {
47715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47716     return 0;
47717   }
47718   {
47719     try {
47720       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47721     } catch (std::out_of_range& e) {
47722       {
47723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47724       };
47725     } catch (std::exception& e) {
47726       {
47727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47728       };
47729     } catch (Dali::DaliException e) {
47730       {
47731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47732       };
47733     } catch (...) {
47734       {
47735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47736       };
47737     }
47738   }
47739
47740   jresult = (void *)result;
47741   return jresult;
47742 }
47743
47744
47745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47746   void * jresult ;
47747   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47748   Dali::NinePatchImage *arg2 = 0 ;
47749   Dali::NinePatchImage *result = 0 ;
47750
47751   arg1 = (Dali::NinePatchImage *)jarg1;
47752   arg2 = (Dali::NinePatchImage *)jarg2;
47753   if (!arg2) {
47754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47755     return 0;
47756   }
47757   {
47758     try {
47759       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47760     } catch (std::out_of_range& e) {
47761       {
47762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47763       };
47764     } catch (std::exception& e) {
47765       {
47766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47767       };
47768     } catch (Dali::DaliException e) {
47769       {
47770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47771       };
47772     } catch (...) {
47773       {
47774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47775       };
47776     }
47777   }
47778
47779   jresult = (void *)result;
47780   return jresult;
47781 }
47782
47783
47784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47785   void * jresult ;
47786   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47787   Dali::Vector4 result;
47788
47789   arg1 = (Dali::NinePatchImage *)jarg1;
47790   {
47791     try {
47792       result = (arg1)->GetStretchBorders();
47793     } catch (std::out_of_range& e) {
47794       {
47795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47796       };
47797     } catch (std::exception& e) {
47798       {
47799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47800       };
47801     } catch (Dali::DaliException e) {
47802       {
47803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47804       };
47805     } catch (...) {
47806       {
47807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47808       };
47809     }
47810   }
47811
47812   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47813   return jresult;
47814 }
47815
47816
47817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47818   void * jresult ;
47819   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47820   Dali::NinePatchImage::StretchRanges *result = 0 ;
47821
47822   arg1 = (Dali::NinePatchImage *)jarg1;
47823   {
47824     try {
47825       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47826     } catch (std::out_of_range& e) {
47827       {
47828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47829       };
47830     } catch (std::exception& e) {
47831       {
47832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47833       };
47834     } catch (Dali::DaliException e) {
47835       {
47836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47837       };
47838     } catch (...) {
47839       {
47840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47841       };
47842     }
47843   }
47844
47845   jresult = (void *)result;
47846   return jresult;
47847 }
47848
47849
47850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47851   void * jresult ;
47852   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47853   Dali::NinePatchImage::StretchRanges *result = 0 ;
47854
47855   arg1 = (Dali::NinePatchImage *)jarg1;
47856   {
47857     try {
47858       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47859     } catch (std::out_of_range& e) {
47860       {
47861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47862       };
47863     } catch (std::exception& e) {
47864       {
47865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47866       };
47867     } catch (Dali::DaliException e) {
47868       {
47869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47870       };
47871     } catch (...) {
47872       {
47873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47874       };
47875     }
47876   }
47877
47878   jresult = (void *)result;
47879   return jresult;
47880 }
47881
47882
47883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47884   void * jresult ;
47885   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47886   Dali::Rect< int > result;
47887
47888   arg1 = (Dali::NinePatchImage *)jarg1;
47889   {
47890     try {
47891       result = (arg1)->GetChildRectangle();
47892     } catch (std::out_of_range& e) {
47893       {
47894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47895       };
47896     } catch (std::exception& e) {
47897       {
47898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47899       };
47900     } catch (Dali::DaliException e) {
47901       {
47902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47903       };
47904     } catch (...) {
47905       {
47906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47907       };
47908     }
47909   }
47910
47911   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47912   return jresult;
47913 }
47914
47915
47916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47917   void * jresult ;
47918   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47919   Dali::BufferImage result;
47920
47921   arg1 = (Dali::NinePatchImage *)jarg1;
47922   {
47923     try {
47924       result = (arg1)->CreateCroppedBufferImage();
47925     } catch (std::out_of_range& e) {
47926       {
47927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47928       };
47929     } catch (std::exception& e) {
47930       {
47931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47932       };
47933     } catch (Dali::DaliException e) {
47934       {
47935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47936       };
47937     } catch (...) {
47938       {
47939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47940       };
47941     }
47942   }
47943
47944   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47945   return jresult;
47946 }
47947
47948
47949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47950   unsigned int jresult ;
47951   std::string *arg1 = 0 ;
47952   bool result;
47953
47954   if (!jarg1) {
47955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47956     return 0;
47957   }
47958   std::string arg1_str(jarg1);
47959   arg1 = &arg1_str;
47960   {
47961     try {
47962       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47963     } catch (std::out_of_range& e) {
47964       {
47965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47966       };
47967     } catch (std::exception& e) {
47968       {
47969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47970       };
47971     } catch (Dali::DaliException e) {
47972       {
47973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47974       };
47975     } catch (...) {
47976       {
47977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47978       };
47979     }
47980   }
47981
47982   jresult = result;
47983
47984   //argout typemap for const std::string&
47985
47986   return jresult;
47987 }
47988
47989
47990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47991   int jresult ;
47992   int result;
47993
47994   result = (int)Dali::CameraActor::Property::TYPE;
47995   jresult = (int)result;
47996   return jresult;
47997 }
47998
47999
48000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
48001   int jresult ;
48002   int result;
48003
48004   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
48005   jresult = (int)result;
48006   return jresult;
48007 }
48008
48009
48010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
48011   int jresult ;
48012   int result;
48013
48014   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
48015   jresult = (int)result;
48016   return jresult;
48017 }
48018
48019
48020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
48021   int jresult ;
48022   int result;
48023
48024   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
48025   jresult = (int)result;
48026   return jresult;
48027 }
48028
48029
48030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
48031   int jresult ;
48032   int result;
48033
48034   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
48035   jresult = (int)result;
48036   return jresult;
48037 }
48038
48039
48040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
48041   int jresult ;
48042   int result;
48043
48044   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
48045   jresult = (int)result;
48046   return jresult;
48047 }
48048
48049
48050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
48051   int jresult ;
48052   int result;
48053
48054   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
48055   jresult = (int)result;
48056   return jresult;
48057 }
48058
48059
48060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
48061   int jresult ;
48062   int result;
48063
48064   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
48065   jresult = (int)result;
48066   return jresult;
48067 }
48068
48069
48070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
48071   int jresult ;
48072   int result;
48073
48074   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
48075   jresult = (int)result;
48076   return jresult;
48077 }
48078
48079
48080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
48081   int jresult ;
48082   int result;
48083
48084   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
48085   jresult = (int)result;
48086   return jresult;
48087 }
48088
48089
48090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48091   int jresult ;
48092   int result;
48093
48094   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48095   jresult = (int)result;
48096   return jresult;
48097 }
48098
48099
48100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48101   int jresult ;
48102   int result;
48103
48104   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48105   jresult = (int)result;
48106   return jresult;
48107 }
48108
48109
48110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48111   int jresult ;
48112   int result;
48113
48114   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48115   jresult = (int)result;
48116   return jresult;
48117 }
48118
48119
48120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48121   int jresult ;
48122   int result;
48123
48124   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48125   jresult = (int)result;
48126   return jresult;
48127 }
48128
48129
48130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48131   void * jresult ;
48132   Dali::CameraActor::Property *result = 0 ;
48133
48134   {
48135     try {
48136       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
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_delete_CameraActor_Property(void * jarg1) {
48162   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48163
48164   arg1 = (Dali::CameraActor::Property *)jarg1;
48165   {
48166     try {
48167       delete arg1;
48168     } catch (std::out_of_range& e) {
48169       {
48170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48171       };
48172     } catch (std::exception& e) {
48173       {
48174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48175       };
48176     } catch (Dali::DaliException e) {
48177       {
48178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48179       };
48180     } catch (...) {
48181       {
48182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48183       };
48184     }
48185   }
48186
48187 }
48188
48189
48190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48191   void * jresult ;
48192   Dali::CameraActor *result = 0 ;
48193
48194   {
48195     try {
48196       result = (Dali::CameraActor *)new Dali::CameraActor();
48197     } catch (std::out_of_range& e) {
48198       {
48199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48200       };
48201     } catch (std::exception& e) {
48202       {
48203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48204       };
48205     } catch (Dali::DaliException e) {
48206       {
48207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48208       };
48209     } catch (...) {
48210       {
48211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48212       };
48213     }
48214   }
48215
48216   jresult = (void *)result;
48217   return jresult;
48218 }
48219
48220
48221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48222   void * jresult ;
48223   Dali::CameraActor result;
48224
48225   {
48226     try {
48227       result = Dali::CameraActor::New();
48228     } catch (std::out_of_range& e) {
48229       {
48230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48231       };
48232     } catch (std::exception& e) {
48233       {
48234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48235       };
48236     } catch (Dali::DaliException e) {
48237       {
48238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48239       };
48240     } catch (...) {
48241       {
48242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48243       };
48244     }
48245   }
48246
48247   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48248   return jresult;
48249 }
48250
48251
48252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48253   void * jresult ;
48254   Dali::Size *arg1 = 0 ;
48255   Dali::CameraActor result;
48256
48257   arg1 = (Dali::Size *)jarg1;
48258   if (!arg1) {
48259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48260     return 0;
48261   }
48262   {
48263     try {
48264       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48265     } catch (std::out_of_range& e) {
48266       {
48267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48268       };
48269     } catch (std::exception& e) {
48270       {
48271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48272       };
48273     } catch (Dali::DaliException e) {
48274       {
48275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48276       };
48277     } catch (...) {
48278       {
48279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48280       };
48281     }
48282   }
48283
48284   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48285   return jresult;
48286 }
48287
48288
48289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48290   void * jresult ;
48291   Dali::BaseHandle arg1 ;
48292   Dali::BaseHandle *argp1 ;
48293   Dali::CameraActor result;
48294
48295   argp1 = (Dali::BaseHandle *)jarg1;
48296   if (!argp1) {
48297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48298     return 0;
48299   }
48300   arg1 = *argp1;
48301   {
48302     try {
48303       result = Dali::CameraActor::DownCast(arg1);
48304     } catch (std::out_of_range& e) {
48305       {
48306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48307       };
48308     } catch (std::exception& e) {
48309       {
48310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48311       };
48312     } catch (Dali::DaliException e) {
48313       {
48314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48315       };
48316     } catch (...) {
48317       {
48318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48319       };
48320     }
48321   }
48322
48323   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48324   return jresult;
48325 }
48326
48327
48328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48329   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48330
48331   arg1 = (Dali::CameraActor *)jarg1;
48332   {
48333     try {
48334       delete arg1;
48335     } catch (std::out_of_range& e) {
48336       {
48337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48338       };
48339     } catch (std::exception& e) {
48340       {
48341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48342       };
48343     } catch (Dali::DaliException e) {
48344       {
48345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48346       };
48347     } catch (...) {
48348       {
48349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48350       };
48351     }
48352   }
48353
48354 }
48355
48356
48357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48358   void * jresult ;
48359   Dali::CameraActor *arg1 = 0 ;
48360   Dali::CameraActor *result = 0 ;
48361
48362   arg1 = (Dali::CameraActor *)jarg1;
48363   if (!arg1) {
48364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48365     return 0;
48366   }
48367   {
48368     try {
48369       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48370     } catch (std::out_of_range& e) {
48371       {
48372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48373       };
48374     } catch (std::exception& e) {
48375       {
48376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48377       };
48378     } catch (Dali::DaliException e) {
48379       {
48380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48381       };
48382     } catch (...) {
48383       {
48384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48385       };
48386     }
48387   }
48388
48389   jresult = (void *)result;
48390   return jresult;
48391 }
48392
48393
48394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48395   void * jresult ;
48396   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48397   Dali::CameraActor *arg2 = 0 ;
48398   Dali::CameraActor *result = 0 ;
48399
48400   arg1 = (Dali::CameraActor *)jarg1;
48401   arg2 = (Dali::CameraActor *)jarg2;
48402   if (!arg2) {
48403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48404     return 0;
48405   }
48406   {
48407     try {
48408       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48409     } catch (std::out_of_range& e) {
48410       {
48411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48412       };
48413     } catch (std::exception& e) {
48414       {
48415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48416       };
48417     } catch (Dali::DaliException e) {
48418       {
48419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48420       };
48421     } catch (...) {
48422       {
48423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48424       };
48425     }
48426   }
48427
48428   jresult = (void *)result;
48429   return jresult;
48430 }
48431
48432
48433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48434   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48435   Dali::Camera::Type arg2 ;
48436
48437   arg1 = (Dali::CameraActor *)jarg1;
48438   arg2 = (Dali::Camera::Type)jarg2;
48439   {
48440     try {
48441       (arg1)->SetType(arg2);
48442     } catch (std::out_of_range& e) {
48443       {
48444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48445       };
48446     } catch (std::exception& e) {
48447       {
48448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48449       };
48450     } catch (Dali::DaliException e) {
48451       {
48452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48453       };
48454     } catch (...) {
48455       {
48456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48457       };
48458     }
48459   }
48460
48461 }
48462
48463
48464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48465   int jresult ;
48466   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48467   Dali::Camera::Type result;
48468
48469   arg1 = (Dali::CameraActor *)jarg1;
48470   {
48471     try {
48472       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48473     } catch (std::out_of_range& e) {
48474       {
48475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48476       };
48477     } catch (std::exception& e) {
48478       {
48479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48480       };
48481     } catch (Dali::DaliException e) {
48482       {
48483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48484       };
48485     } catch (...) {
48486       {
48487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48488       };
48489     }
48490   }
48491
48492   jresult = (int)result;
48493   return jresult;
48494 }
48495
48496
48497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48498   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48499   Dali::Camera::ProjectionMode arg2 ;
48500
48501   arg1 = (Dali::CameraActor *)jarg1;
48502   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48503   {
48504     try {
48505       (arg1)->SetProjectionMode(arg2);
48506     } catch (std::out_of_range& e) {
48507       {
48508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48509       };
48510     } catch (std::exception& e) {
48511       {
48512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48513       };
48514     } catch (Dali::DaliException e) {
48515       {
48516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48517       };
48518     } catch (...) {
48519       {
48520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48521       };
48522     }
48523   }
48524
48525 }
48526
48527
48528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48529   int jresult ;
48530   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48531   Dali::Camera::ProjectionMode result;
48532
48533   arg1 = (Dali::CameraActor *)jarg1;
48534   {
48535     try {
48536       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48537     } catch (std::out_of_range& e) {
48538       {
48539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48540       };
48541     } catch (std::exception& e) {
48542       {
48543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48544       };
48545     } catch (Dali::DaliException e) {
48546       {
48547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48548       };
48549     } catch (...) {
48550       {
48551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48552       };
48553     }
48554   }
48555
48556   jresult = (int)result;
48557   return jresult;
48558 }
48559
48560
48561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48562   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48563   float arg2 ;
48564
48565   arg1 = (Dali::CameraActor *)jarg1;
48566   arg2 = (float)jarg2;
48567   {
48568     try {
48569       (arg1)->SetFieldOfView(arg2);
48570     } catch (std::out_of_range& e) {
48571       {
48572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48573       };
48574     } catch (std::exception& e) {
48575       {
48576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48577       };
48578     } catch (Dali::DaliException e) {
48579       {
48580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48581       };
48582     } catch (...) {
48583       {
48584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48585       };
48586     }
48587   }
48588
48589 }
48590
48591
48592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48593   float jresult ;
48594   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48595   float result;
48596
48597   arg1 = (Dali::CameraActor *)jarg1;
48598   {
48599     try {
48600       result = (float)(arg1)->GetFieldOfView();
48601     } catch (std::out_of_range& e) {
48602       {
48603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48604       };
48605     } catch (std::exception& e) {
48606       {
48607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48608       };
48609     } catch (Dali::DaliException e) {
48610       {
48611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48612       };
48613     } catch (...) {
48614       {
48615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48616       };
48617     }
48618   }
48619
48620   jresult = result;
48621   return jresult;
48622 }
48623
48624
48625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48626   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48627   float arg2 ;
48628
48629   arg1 = (Dali::CameraActor *)jarg1;
48630   arg2 = (float)jarg2;
48631   {
48632     try {
48633       (arg1)->SetAspectRatio(arg2);
48634     } catch (std::out_of_range& e) {
48635       {
48636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48637       };
48638     } catch (std::exception& e) {
48639       {
48640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48641       };
48642     } catch (Dali::DaliException e) {
48643       {
48644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48645       };
48646     } catch (...) {
48647       {
48648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48649       };
48650     }
48651   }
48652
48653 }
48654
48655
48656 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48657   float jresult ;
48658   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48659   float result;
48660
48661   arg1 = (Dali::CameraActor *)jarg1;
48662   {
48663     try {
48664       result = (float)(arg1)->GetAspectRatio();
48665     } catch (std::out_of_range& e) {
48666       {
48667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48668       };
48669     } catch (std::exception& e) {
48670       {
48671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48672       };
48673     } catch (Dali::DaliException e) {
48674       {
48675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48676       };
48677     } catch (...) {
48678       {
48679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48680       };
48681     }
48682   }
48683
48684   jresult = result;
48685   return jresult;
48686 }
48687
48688
48689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48690   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48691   float arg2 ;
48692
48693   arg1 = (Dali::CameraActor *)jarg1;
48694   arg2 = (float)jarg2;
48695   {
48696     try {
48697       (arg1)->SetNearClippingPlane(arg2);
48698     } catch (std::out_of_range& e) {
48699       {
48700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48701       };
48702     } catch (std::exception& e) {
48703       {
48704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48705       };
48706     } catch (Dali::DaliException e) {
48707       {
48708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48709       };
48710     } catch (...) {
48711       {
48712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48713       };
48714     }
48715   }
48716
48717 }
48718
48719
48720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48721   float jresult ;
48722   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48723   float result;
48724
48725   arg1 = (Dali::CameraActor *)jarg1;
48726   {
48727     try {
48728       result = (float)(arg1)->GetNearClippingPlane();
48729     } catch (std::out_of_range& e) {
48730       {
48731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48732       };
48733     } catch (std::exception& e) {
48734       {
48735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48736       };
48737     } catch (Dali::DaliException e) {
48738       {
48739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48740       };
48741     } catch (...) {
48742       {
48743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48744       };
48745     }
48746   }
48747
48748   jresult = result;
48749   return jresult;
48750 }
48751
48752
48753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48754   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48755   float arg2 ;
48756
48757   arg1 = (Dali::CameraActor *)jarg1;
48758   arg2 = (float)jarg2;
48759   {
48760     try {
48761       (arg1)->SetFarClippingPlane(arg2);
48762     } catch (std::out_of_range& e) {
48763       {
48764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48765       };
48766     } catch (std::exception& e) {
48767       {
48768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48769       };
48770     } catch (Dali::DaliException e) {
48771       {
48772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48773       };
48774     } catch (...) {
48775       {
48776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48777       };
48778     }
48779   }
48780
48781 }
48782
48783
48784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48785   float jresult ;
48786   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48787   float result;
48788
48789   arg1 = (Dali::CameraActor *)jarg1;
48790   {
48791     try {
48792       result = (float)(arg1)->GetFarClippingPlane();
48793     } catch (std::out_of_range& e) {
48794       {
48795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48796       };
48797     } catch (std::exception& e) {
48798       {
48799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48800       };
48801     } catch (Dali::DaliException e) {
48802       {
48803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48804       };
48805     } catch (...) {
48806       {
48807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48808       };
48809     }
48810   }
48811
48812   jresult = result;
48813   return jresult;
48814 }
48815
48816
48817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48818   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48819   Dali::Vector3 *arg2 = 0 ;
48820
48821   arg1 = (Dali::CameraActor *)jarg1;
48822   arg2 = (Dali::Vector3 *)jarg2;
48823   if (!arg2) {
48824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48825     return ;
48826   }
48827   {
48828     try {
48829       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48830     } catch (std::out_of_range& e) {
48831       {
48832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48833       };
48834     } catch (std::exception& e) {
48835       {
48836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48837       };
48838     } catch (Dali::DaliException e) {
48839       {
48840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48841       };
48842     } catch (...) {
48843       {
48844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48845       };
48846     }
48847   }
48848
48849 }
48850
48851
48852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48853   void * jresult ;
48854   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48855   Dali::Vector3 result;
48856
48857   arg1 = (Dali::CameraActor *)jarg1;
48858   {
48859     try {
48860       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48861     } catch (std::out_of_range& e) {
48862       {
48863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48864       };
48865     } catch (std::exception& e) {
48866       {
48867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48868       };
48869     } catch (Dali::DaliException e) {
48870       {
48871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48872       };
48873     } catch (...) {
48874       {
48875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48876       };
48877     }
48878   }
48879
48880   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48881   return jresult;
48882 }
48883
48884
48885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48886   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48887   bool arg2 ;
48888
48889   arg1 = (Dali::CameraActor *)jarg1;
48890   arg2 = jarg2 ? true : false;
48891   {
48892     try {
48893       (arg1)->SetInvertYAxis(arg2);
48894     } catch (std::out_of_range& e) {
48895       {
48896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48897       };
48898     } catch (std::exception& e) {
48899       {
48900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48901       };
48902     } catch (Dali::DaliException e) {
48903       {
48904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48905       };
48906     } catch (...) {
48907       {
48908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48909       };
48910     }
48911   }
48912
48913 }
48914
48915
48916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48917   unsigned int jresult ;
48918   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48919   bool result;
48920
48921   arg1 = (Dali::CameraActor *)jarg1;
48922   {
48923     try {
48924       result = (bool)(arg1)->GetInvertYAxis();
48925     } catch (std::out_of_range& e) {
48926       {
48927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48928       };
48929     } catch (std::exception& e) {
48930       {
48931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48932       };
48933     } catch (Dali::DaliException e) {
48934       {
48935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48936       };
48937     } catch (...) {
48938       {
48939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48940       };
48941     }
48942   }
48943
48944   jresult = result;
48945   return jresult;
48946 }
48947
48948
48949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48950   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48951   Dali::Size *arg2 = 0 ;
48952
48953   arg1 = (Dali::CameraActor *)jarg1;
48954   arg2 = (Dali::Size *)jarg2;
48955   if (!arg2) {
48956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48957     return ;
48958   }
48959   {
48960     try {
48961       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48962     } catch (std::out_of_range& e) {
48963       {
48964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48965       };
48966     } catch (std::exception& e) {
48967       {
48968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48969       };
48970     } catch (Dali::DaliException e) {
48971       {
48972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48973       };
48974     } catch (...) {
48975       {
48976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48977       };
48978     }
48979   }
48980
48981 }
48982
48983
48984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48985   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48986   Dali::Size *arg2 = 0 ;
48987
48988   arg1 = (Dali::CameraActor *)jarg1;
48989   arg2 = (Dali::Size *)jarg2;
48990   if (!arg2) {
48991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48992     return ;
48993   }
48994   {
48995     try {
48996       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48997     } catch (std::out_of_range& e) {
48998       {
48999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49000       };
49001     } catch (std::exception& e) {
49002       {
49003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49004       };
49005     } catch (Dali::DaliException e) {
49006       {
49007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49008       };
49009     } catch (...) {
49010       {
49011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49012       };
49013     }
49014   }
49015
49016 }
49017
49018
49019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
49020   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
49021   float arg2 ;
49022   float arg3 ;
49023   float arg4 ;
49024   float arg5 ;
49025   float arg6 ;
49026   float arg7 ;
49027
49028   arg1 = (Dali::CameraActor *)jarg1;
49029   arg2 = (float)jarg2;
49030   arg3 = (float)jarg3;
49031   arg4 = (float)jarg4;
49032   arg5 = (float)jarg5;
49033   arg6 = (float)jarg6;
49034   arg7 = (float)jarg7;
49035   {
49036     try {
49037       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
49038     } catch (std::out_of_range& e) {
49039       {
49040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49041       };
49042     } catch (std::exception& e) {
49043       {
49044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49045       };
49046     } catch (Dali::DaliException e) {
49047       {
49048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49049       };
49050     } catch (...) {
49051       {
49052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49053       };
49054     }
49055   }
49056
49057 }
49058
49059
49060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
49061   void * jresult ;
49062   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49063
49064   {
49065     try {
49066       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
49067     } catch (std::out_of_range& e) {
49068       {
49069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49070       };
49071     } catch (std::exception& e) {
49072       {
49073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49074       };
49075     } catch (Dali::DaliException e) {
49076       {
49077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49078       };
49079     } catch (...) {
49080       {
49081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49082       };
49083     }
49084   }
49085
49086   jresult = (void *)result;
49087   return jresult;
49088 }
49089
49090
49091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49092   void * jresult ;
49093   std::string arg1 ;
49094   Dali::Property::Value arg2 ;
49095   Dali::Property::Value *argp2 ;
49096   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49097
49098   if (!jarg1) {
49099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49100     return 0;
49101   }
49102   (&arg1)->assign(jarg1);
49103   argp2 = (Dali::Property::Value *)jarg2;
49104   if (!argp2) {
49105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49106     return 0;
49107   }
49108   arg2 = *argp2;
49109   {
49110     try {
49111       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49112     } catch (std::out_of_range& e) {
49113       {
49114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49115       };
49116     } catch (std::exception& e) {
49117       {
49118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49119       };
49120     } catch (Dali::DaliException e) {
49121       {
49122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49123       };
49124     } catch (...) {
49125       {
49126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49127       };
49128     }
49129   }
49130
49131   jresult = (void *)result;
49132   return jresult;
49133 }
49134
49135
49136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49137   void * jresult ;
49138   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49139   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49140
49141   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49142   if (!arg1) {
49143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49144     return 0;
49145   }
49146   {
49147     try {
49148       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);
49149     } catch (std::out_of_range& e) {
49150       {
49151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49152       };
49153     } catch (std::exception& e) {
49154       {
49155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49156       };
49157     } catch (Dali::DaliException e) {
49158       {
49159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49160       };
49161     } catch (...) {
49162       {
49163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49164       };
49165     }
49166   }
49167
49168   jresult = (void *)result;
49169   return jresult;
49170 }
49171
49172
49173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49174   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49175   std::string *arg2 = 0 ;
49176
49177   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49178   if (!jarg2) {
49179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49180     return ;
49181   }
49182   std::string arg2_str(jarg2);
49183   arg2 = &arg2_str;
49184   if (arg1) (arg1)->first = *arg2;
49185
49186   //argout typemap for const std::string&
49187
49188 }
49189
49190
49191 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49192   char * jresult ;
49193   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49194   std::string *result = 0 ;
49195
49196   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49197   result = (std::string *) & ((arg1)->first);
49198   jresult = SWIG_csharp_string_callback(result->c_str());
49199   return jresult;
49200 }
49201
49202
49203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49204   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49205   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49206
49207   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49208   arg2 = (Dali::Property::Value *)jarg2;
49209   if (arg1) (arg1)->second = *arg2;
49210 }
49211
49212
49213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49214   void * jresult ;
49215   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49216   Dali::Property::Value *result = 0 ;
49217
49218   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49219   result = (Dali::Property::Value *)& ((arg1)->second);
49220   jresult = (void *)result;
49221   return jresult;
49222 }
49223
49224
49225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49226   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49227
49228   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49229   {
49230     try {
49231       delete arg1;
49232     } catch (std::out_of_range& e) {
49233       {
49234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49235       };
49236     } catch (std::exception& e) {
49237       {
49238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49239       };
49240     } catch (Dali::DaliException e) {
49241       {
49242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49243       };
49244     } catch (...) {
49245       {
49246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49247       };
49248     }
49249   }
49250
49251 }
49252
49253
49254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49255   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49256
49257   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49258   {
49259     try {
49260       (arg1)->clear();
49261     } catch (std::out_of_range& e) {
49262       {
49263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49264       };
49265     } catch (std::exception& e) {
49266       {
49267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49268       };
49269     } catch (Dali::DaliException e) {
49270       {
49271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49272       };
49273     } catch (...) {
49274       {
49275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49276       };
49277     }
49278   }
49279
49280 }
49281
49282
49283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49284   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49285   Dali::TouchPoint *arg2 = 0 ;
49286
49287   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49288   arg2 = (Dali::TouchPoint *)jarg2;
49289   if (!arg2) {
49290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49291     return ;
49292   }
49293   {
49294     try {
49295       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49296     } catch (std::out_of_range& e) {
49297       {
49298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49299       };
49300     } catch (std::exception& e) {
49301       {
49302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49303       };
49304     } catch (Dali::DaliException e) {
49305       {
49306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49307       };
49308     } catch (...) {
49309       {
49310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49311       };
49312     }
49313   }
49314
49315 }
49316
49317
49318 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49319   unsigned long jresult ;
49320   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49321   std::vector< Dali::TouchPoint >::size_type result;
49322
49323   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49324   {
49325     try {
49326       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49327     } catch (std::out_of_range& e) {
49328       {
49329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49330       };
49331     } catch (std::exception& e) {
49332       {
49333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49334       };
49335     } catch (Dali::DaliException e) {
49336       {
49337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49338       };
49339     } catch (...) {
49340       {
49341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49342       };
49343     }
49344   }
49345
49346   jresult = (unsigned long)result;
49347   return jresult;
49348 }
49349
49350
49351 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49352   unsigned long jresult ;
49353   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49354   std::vector< Dali::TouchPoint >::size_type result;
49355
49356   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49357   {
49358     try {
49359       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49360     } catch (std::out_of_range& e) {
49361       {
49362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49363       };
49364     } catch (std::exception& e) {
49365       {
49366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49367       };
49368     } catch (Dali::DaliException e) {
49369       {
49370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49371       };
49372     } catch (...) {
49373       {
49374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49375       };
49376     }
49377   }
49378
49379   jresult = (unsigned long)result;
49380   return jresult;
49381 }
49382
49383
49384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49385   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49386   std::vector< Dali::TouchPoint >::size_type arg2 ;
49387
49388   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49389   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49390   {
49391     try {
49392       (arg1)->reserve(arg2);
49393     } catch (std::out_of_range& e) {
49394       {
49395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49396       };
49397     } catch (std::exception& e) {
49398       {
49399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49400       };
49401     } catch (Dali::DaliException e) {
49402       {
49403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49404       };
49405     } catch (...) {
49406       {
49407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49408       };
49409     }
49410   }
49411
49412 }
49413
49414
49415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49416   void * jresult ;
49417   std::vector< Dali::TouchPoint > *result = 0 ;
49418
49419   {
49420     try {
49421       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49422     } catch (std::out_of_range& e) {
49423       {
49424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49425       };
49426     } catch (std::exception& e) {
49427       {
49428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49429       };
49430     } catch (Dali::DaliException e) {
49431       {
49432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49433       };
49434     } catch (...) {
49435       {
49436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49437       };
49438     }
49439   }
49440
49441   jresult = (void *)result;
49442   return jresult;
49443 }
49444
49445
49446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49447   void * jresult ;
49448   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49449   std::vector< Dali::TouchPoint > *result = 0 ;
49450
49451   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49452   if (!arg1) {
49453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49454     return 0;
49455   }
49456   {
49457     try {
49458       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49459     } catch (std::out_of_range& e) {
49460       {
49461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49462       };
49463     } catch (std::exception& e) {
49464       {
49465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49466       };
49467     } catch (Dali::DaliException e) {
49468       {
49469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49470       };
49471     } catch (...) {
49472       {
49473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49474       };
49475     }
49476   }
49477
49478   jresult = (void *)result;
49479   return jresult;
49480 }
49481
49482
49483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49484   void * jresult ;
49485   int arg1 ;
49486   std::vector< Dali::TouchPoint > *result = 0 ;
49487
49488   arg1 = (int)jarg1;
49489   {
49490     try {
49491       try {
49492         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49493       }
49494       catch(std::out_of_range &_e) {
49495         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49496         return 0;
49497       }
49498
49499     } catch (std::out_of_range& e) {
49500       {
49501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49502       };
49503     } catch (std::exception& e) {
49504       {
49505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49506       };
49507     } catch (Dali::DaliException e) {
49508       {
49509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49510       };
49511     } catch (...) {
49512       {
49513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49514       };
49515     }
49516   }
49517
49518   jresult = (void *)result;
49519   return jresult;
49520 }
49521
49522
49523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49524   void * jresult ;
49525   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49526   int arg2 ;
49527   SwigValueWrapper< Dali::TouchPoint > result;
49528
49529   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49530   arg2 = (int)jarg2;
49531   {
49532     try {
49533       try {
49534         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49535       }
49536       catch(std::out_of_range &_e) {
49537         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49538         return 0;
49539       }
49540
49541     } catch (std::out_of_range& e) {
49542       {
49543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49544       };
49545     } catch (std::exception& e) {
49546       {
49547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49548       };
49549     } catch (Dali::DaliException e) {
49550       {
49551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49552       };
49553     } catch (...) {
49554       {
49555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49556       };
49557     }
49558   }
49559
49560   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49561   return jresult;
49562 }
49563
49564
49565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49566   void * jresult ;
49567   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49568   int arg2 ;
49569   Dali::TouchPoint *result = 0 ;
49570
49571   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49572   arg2 = (int)jarg2;
49573   {
49574     try {
49575       try {
49576         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49577       }
49578       catch(std::out_of_range &_e) {
49579         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49580         return 0;
49581       }
49582
49583     } catch (std::out_of_range& e) {
49584       {
49585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49586       };
49587     } catch (std::exception& e) {
49588       {
49589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49590       };
49591     } catch (Dali::DaliException e) {
49592       {
49593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49594       };
49595     } catch (...) {
49596       {
49597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49598       };
49599     }
49600   }
49601
49602   jresult = (void *)result;
49603   return jresult;
49604 }
49605
49606
49607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49608   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49609   int arg2 ;
49610   Dali::TouchPoint *arg3 = 0 ;
49611
49612   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49613   arg2 = (int)jarg2;
49614   arg3 = (Dali::TouchPoint *)jarg3;
49615   if (!arg3) {
49616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49617     return ;
49618   }
49619   {
49620     try {
49621       try {
49622         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49623       }
49624       catch(std::out_of_range &_e) {
49625         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49626         return ;
49627       }
49628
49629     } catch (std::out_of_range& e) {
49630       {
49631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49632       };
49633     } catch (std::exception& e) {
49634       {
49635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49636       };
49637     } catch (Dali::DaliException e) {
49638       {
49639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49640       };
49641     } catch (...) {
49642       {
49643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49644       };
49645     }
49646   }
49647
49648 }
49649
49650
49651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49652   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49653   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49654
49655   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49656   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49657   if (!arg2) {
49658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49659     return ;
49660   }
49661   {
49662     try {
49663       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49664     } catch (std::out_of_range& e) {
49665       {
49666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49667       };
49668     } catch (std::exception& e) {
49669       {
49670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49671       };
49672     } catch (Dali::DaliException e) {
49673       {
49674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49675       };
49676     } catch (...) {
49677       {
49678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49679       };
49680     }
49681   }
49682
49683 }
49684
49685
49686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49687   void * jresult ;
49688   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49689   int arg2 ;
49690   int arg3 ;
49691   std::vector< Dali::TouchPoint > *result = 0 ;
49692
49693   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49694   arg2 = (int)jarg2;
49695   arg3 = (int)jarg3;
49696   {
49697     try {
49698       try {
49699         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49700       }
49701       catch(std::out_of_range &_e) {
49702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49703         return 0;
49704       }
49705       catch(std::invalid_argument &_e) {
49706         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49707         return 0;
49708       }
49709
49710     } catch (std::out_of_range& e) {
49711       {
49712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49713       };
49714     } catch (std::exception& e) {
49715       {
49716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49717       };
49718     } catch (Dali::DaliException e) {
49719       {
49720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49721       };
49722     } catch (...) {
49723       {
49724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49725       };
49726     }
49727   }
49728
49729   jresult = (void *)result;
49730   return jresult;
49731 }
49732
49733
49734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49735   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49736   int arg2 ;
49737   Dali::TouchPoint *arg3 = 0 ;
49738
49739   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49740   arg2 = (int)jarg2;
49741   arg3 = (Dali::TouchPoint *)jarg3;
49742   if (!arg3) {
49743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49744     return ;
49745   }
49746   {
49747     try {
49748       try {
49749         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49750       }
49751       catch(std::out_of_range &_e) {
49752         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49753         return ;
49754       }
49755
49756     } catch (std::out_of_range& e) {
49757       {
49758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49759       };
49760     } catch (std::exception& e) {
49761       {
49762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49763       };
49764     } catch (Dali::DaliException e) {
49765       {
49766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49767       };
49768     } catch (...) {
49769       {
49770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49771       };
49772     }
49773   }
49774
49775 }
49776
49777
49778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49779   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49780   int arg2 ;
49781   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49782
49783   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49784   arg2 = (int)jarg2;
49785   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49786   if (!arg3) {
49787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49788     return ;
49789   }
49790   {
49791     try {
49792       try {
49793         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49794       }
49795       catch(std::out_of_range &_e) {
49796         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49797         return ;
49798       }
49799
49800     } catch (std::out_of_range& e) {
49801       {
49802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49803       };
49804     } catch (std::exception& e) {
49805       {
49806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49807       };
49808     } catch (Dali::DaliException e) {
49809       {
49810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49811       };
49812     } catch (...) {
49813       {
49814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49815       };
49816     }
49817   }
49818
49819 }
49820
49821
49822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49823   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49824   int arg2 ;
49825
49826   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49827   arg2 = (int)jarg2;
49828   {
49829     try {
49830       try {
49831         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49832       }
49833       catch(std::out_of_range &_e) {
49834         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49835         return ;
49836       }
49837
49838     } catch (std::out_of_range& e) {
49839       {
49840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49841       };
49842     } catch (std::exception& e) {
49843       {
49844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49845       };
49846     } catch (Dali::DaliException e) {
49847       {
49848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49849       };
49850     } catch (...) {
49851       {
49852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49853       };
49854     }
49855   }
49856
49857 }
49858
49859
49860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49861   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49862   int arg2 ;
49863   int arg3 ;
49864
49865   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49866   arg2 = (int)jarg2;
49867   arg3 = (int)jarg3;
49868   {
49869     try {
49870       try {
49871         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49872       }
49873       catch(std::out_of_range &_e) {
49874         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49875         return ;
49876       }
49877       catch(std::invalid_argument &_e) {
49878         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49879         return ;
49880       }
49881
49882     } catch (std::out_of_range& e) {
49883       {
49884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49885       };
49886     } catch (std::exception& e) {
49887       {
49888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49889       };
49890     } catch (Dali::DaliException e) {
49891       {
49892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49893       };
49894     } catch (...) {
49895       {
49896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49897       };
49898     }
49899   }
49900
49901 }
49902
49903
49904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49905   void * jresult ;
49906   Dali::TouchPoint *arg1 = 0 ;
49907   int arg2 ;
49908   std::vector< Dali::TouchPoint > *result = 0 ;
49909
49910   arg1 = (Dali::TouchPoint *)jarg1;
49911   if (!arg1) {
49912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49913     return 0;
49914   }
49915   arg2 = (int)jarg2;
49916   {
49917     try {
49918       try {
49919         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49920       }
49921       catch(std::out_of_range &_e) {
49922         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49923         return 0;
49924       }
49925
49926     } catch (std::out_of_range& e) {
49927       {
49928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49929       };
49930     } catch (std::exception& e) {
49931       {
49932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49933       };
49934     } catch (Dali::DaliException e) {
49935       {
49936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49937       };
49938     } catch (...) {
49939       {
49940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49941       };
49942     }
49943   }
49944
49945   jresult = (void *)result;
49946   return jresult;
49947 }
49948
49949
49950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49951   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49952
49953   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49954   {
49955     try {
49956       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49957     } catch (std::out_of_range& e) {
49958       {
49959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49960       };
49961     } catch (std::exception& e) {
49962       {
49963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49964       };
49965     } catch (Dali::DaliException e) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49968       };
49969     } catch (...) {
49970       {
49971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49972       };
49973     }
49974   }
49975
49976 }
49977
49978
49979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49980   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49981   int arg2 ;
49982   int arg3 ;
49983
49984   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49985   arg2 = (int)jarg2;
49986   arg3 = (int)jarg3;
49987   {
49988     try {
49989       try {
49990         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49991       }
49992       catch(std::out_of_range &_e) {
49993         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49994         return ;
49995       }
49996       catch(std::invalid_argument &_e) {
49997         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49998         return ;
49999       }
50000
50001     } catch (std::out_of_range& e) {
50002       {
50003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50004       };
50005     } catch (std::exception& e) {
50006       {
50007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50008       };
50009     } catch (Dali::DaliException e) {
50010       {
50011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50012       };
50013     } catch (...) {
50014       {
50015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50016       };
50017     }
50018   }
50019
50020 }
50021
50022
50023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
50024   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50025   int arg2 ;
50026   std::vector< Dali::TouchPoint > *arg3 = 0 ;
50027
50028   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50029   arg2 = (int)jarg2;
50030   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
50031   if (!arg3) {
50032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
50033     return ;
50034   }
50035   {
50036     try {
50037       try {
50038         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
50039       }
50040       catch(std::out_of_range &_e) {
50041         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
50042         return ;
50043       }
50044
50045     } catch (std::out_of_range& e) {
50046       {
50047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50048       };
50049     } catch (std::exception& e) {
50050       {
50051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50052       };
50053     } catch (Dali::DaliException e) {
50054       {
50055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50056       };
50057     } catch (...) {
50058       {
50059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50060       };
50061     }
50062   }
50063
50064 }
50065
50066
50067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
50068   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
50069
50070   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
50071   {
50072     try {
50073       delete arg1;
50074     } catch (std::out_of_range& e) {
50075       {
50076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50077       };
50078     } catch (std::exception& e) {
50079       {
50080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50081       };
50082     } catch (Dali::DaliException e) {
50083       {
50084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50085       };
50086     } catch (...) {
50087       {
50088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50089       };
50090     }
50091   }
50092
50093 }
50094
50095
50096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50097   void * jresult ;
50098   Dali::Rect< int > *result = 0 ;
50099
50100   {
50101     try {
50102       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50103     } catch (std::out_of_range& e) {
50104       {
50105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50106       };
50107     } catch (std::exception& e) {
50108       {
50109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50110       };
50111     } catch (Dali::DaliException e) {
50112       {
50113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50114       };
50115     } catch (...) {
50116       {
50117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50118       };
50119     }
50120   }
50121
50122   jresult = (void *)result;
50123   return jresult;
50124 }
50125
50126
50127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50128   void * jresult ;
50129   int arg1 ;
50130   int arg2 ;
50131   int arg3 ;
50132   int arg4 ;
50133   Dali::Rect< int > *result = 0 ;
50134
50135   arg1 = (int)jarg1;
50136   arg2 = (int)jarg2;
50137   arg3 = (int)jarg3;
50138   arg4 = (int)jarg4;
50139   {
50140     try {
50141       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50142     } catch (std::out_of_range& e) {
50143       {
50144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50145       };
50146     } catch (std::exception& e) {
50147       {
50148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50149       };
50150     } catch (Dali::DaliException e) {
50151       {
50152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50153       };
50154     } catch (...) {
50155       {
50156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50157       };
50158     }
50159   }
50160
50161   jresult = (void *)result;
50162   return jresult;
50163 }
50164
50165
50166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50167   void * jresult ;
50168   Dali::Rect< int > *arg1 = 0 ;
50169   Dali::Rect< int > *result = 0 ;
50170
50171   arg1 = (Dali::Rect< int > *)jarg1;
50172   if (!arg1) {
50173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50174     return 0;
50175   }
50176   {
50177     try {
50178       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50179     } catch (std::out_of_range& e) {
50180       {
50181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50182       };
50183     } catch (std::exception& e) {
50184       {
50185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50186       };
50187     } catch (Dali::DaliException e) {
50188       {
50189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50190       };
50191     } catch (...) {
50192       {
50193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50194       };
50195     }
50196   }
50197
50198   jresult = (void *)result;
50199   return jresult;
50200 }
50201
50202
50203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50204   void * jresult ;
50205   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50206   Dali::Rect< int > *arg2 = 0 ;
50207   Dali::Rect< int > *result = 0 ;
50208
50209   arg1 = (Dali::Rect< int > *)jarg1;
50210   arg2 = (Dali::Rect< int > *)jarg2;
50211   if (!arg2) {
50212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50213     return 0;
50214   }
50215   {
50216     try {
50217       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50218     } catch (std::out_of_range& e) {
50219       {
50220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50221       };
50222     } catch (std::exception& e) {
50223       {
50224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50225       };
50226     } catch (Dali::DaliException e) {
50227       {
50228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50229       };
50230     } catch (...) {
50231       {
50232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50233       };
50234     }
50235   }
50236
50237   jresult = (void *)result;
50238   return jresult;
50239 }
50240
50241
50242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50243   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50244   int arg2 ;
50245   int arg3 ;
50246   int arg4 ;
50247   int arg5 ;
50248
50249   arg1 = (Dali::Rect< int > *)jarg1;
50250   arg2 = (int)jarg2;
50251   arg3 = (int)jarg3;
50252   arg4 = (int)jarg4;
50253   arg5 = (int)jarg5;
50254   {
50255     try {
50256       (arg1)->Set(arg2,arg3,arg4,arg5);
50257     } catch (std::out_of_range& e) {
50258       {
50259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50260       };
50261     } catch (std::exception& e) {
50262       {
50263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50264       };
50265     } catch (Dali::DaliException e) {
50266       {
50267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50268       };
50269     } catch (...) {
50270       {
50271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50272       };
50273     }
50274   }
50275
50276 }
50277
50278
50279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50280   unsigned int jresult ;
50281   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50282   bool result;
50283
50284   arg1 = (Dali::Rect< int > *)jarg1;
50285   {
50286     try {
50287       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50288     } catch (std::out_of_range& e) {
50289       {
50290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50291       };
50292     } catch (std::exception& e) {
50293       {
50294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50295       };
50296     } catch (Dali::DaliException e) {
50297       {
50298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50299       };
50300     } catch (...) {
50301       {
50302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50303       };
50304     }
50305   }
50306
50307   jresult = result;
50308   return jresult;
50309 }
50310
50311
50312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50313   int jresult ;
50314   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50315   int result;
50316
50317   arg1 = (Dali::Rect< int > *)jarg1;
50318   {
50319     try {
50320       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50321     } catch (std::out_of_range& e) {
50322       {
50323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50324       };
50325     } catch (std::exception& e) {
50326       {
50327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50328       };
50329     } catch (Dali::DaliException e) {
50330       {
50331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50332       };
50333     } catch (...) {
50334       {
50335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50336       };
50337     }
50338   }
50339
50340   jresult = result;
50341   return jresult;
50342 }
50343
50344
50345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50346   int jresult ;
50347   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50348   int result;
50349
50350   arg1 = (Dali::Rect< int > *)jarg1;
50351   {
50352     try {
50353       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50354     } catch (std::out_of_range& e) {
50355       {
50356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50357       };
50358     } catch (std::exception& e) {
50359       {
50360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50361       };
50362     } catch (Dali::DaliException e) {
50363       {
50364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50365       };
50366     } catch (...) {
50367       {
50368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50369       };
50370     }
50371   }
50372
50373   jresult = result;
50374   return jresult;
50375 }
50376
50377
50378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50379   int jresult ;
50380   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50381   int result;
50382
50383   arg1 = (Dali::Rect< int > *)jarg1;
50384   {
50385     try {
50386       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50387     } catch (std::out_of_range& e) {
50388       {
50389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50390       };
50391     } catch (std::exception& e) {
50392       {
50393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50394       };
50395     } catch (Dali::DaliException e) {
50396       {
50397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50398       };
50399     } catch (...) {
50400       {
50401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50402       };
50403     }
50404   }
50405
50406   jresult = result;
50407   return jresult;
50408 }
50409
50410
50411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50412   int jresult ;
50413   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50414   int result;
50415
50416   arg1 = (Dali::Rect< int > *)jarg1;
50417   {
50418     try {
50419       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50420     } catch (std::out_of_range& e) {
50421       {
50422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50423       };
50424     } catch (std::exception& e) {
50425       {
50426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50427       };
50428     } catch (Dali::DaliException e) {
50429       {
50430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50431       };
50432     } catch (...) {
50433       {
50434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50435       };
50436     }
50437   }
50438
50439   jresult = result;
50440   return jresult;
50441 }
50442
50443
50444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50445   int jresult ;
50446   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50447   int result;
50448
50449   arg1 = (Dali::Rect< int > *)jarg1;
50450   {
50451     try {
50452       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50453     } catch (std::out_of_range& e) {
50454       {
50455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50456       };
50457     } catch (std::exception& e) {
50458       {
50459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50460       };
50461     } catch (Dali::DaliException e) {
50462       {
50463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50464       };
50465     } catch (...) {
50466       {
50467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50468       };
50469     }
50470   }
50471
50472   jresult = result;
50473   return jresult;
50474 }
50475
50476
50477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50478   unsigned int jresult ;
50479   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50480   Dali::Rect< int > *arg2 = 0 ;
50481   bool result;
50482
50483   arg1 = (Dali::Rect< int > *)jarg1;
50484   arg2 = (Dali::Rect< int > *)jarg2;
50485   if (!arg2) {
50486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50487     return 0;
50488   }
50489   {
50490     try {
50491       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50492     } catch (std::out_of_range& e) {
50493       {
50494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50495       };
50496     } catch (std::exception& e) {
50497       {
50498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50499       };
50500     } catch (Dali::DaliException e) {
50501       {
50502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50503       };
50504     } catch (...) {
50505       {
50506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50507       };
50508     }
50509   }
50510
50511   jresult = result;
50512   return jresult;
50513 }
50514
50515
50516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50517   unsigned int jresult ;
50518   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50519   Dali::Rect< int > *arg2 = 0 ;
50520   bool result;
50521
50522   arg1 = (Dali::Rect< int > *)jarg1;
50523   arg2 = (Dali::Rect< int > *)jarg2;
50524   if (!arg2) {
50525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50526     return 0;
50527   }
50528   {
50529     try {
50530       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50531     } catch (std::out_of_range& e) {
50532       {
50533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50534       };
50535     } catch (std::exception& e) {
50536       {
50537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50538       };
50539     } catch (Dali::DaliException e) {
50540       {
50541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50542       };
50543     } catch (...) {
50544       {
50545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50546       };
50547     }
50548   }
50549
50550   jresult = result;
50551   return jresult;
50552 }
50553
50554
50555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50556   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50557   int arg2 ;
50558
50559   arg1 = (Dali::Rect< int > *)jarg1;
50560   arg2 = (int)jarg2;
50561   if (arg1) (arg1)->x = arg2;
50562 }
50563
50564
50565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50566   int jresult ;
50567   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50568   int result;
50569
50570   arg1 = (Dali::Rect< int > *)jarg1;
50571   result = (int) ((arg1)->x);
50572   jresult = result;
50573   return jresult;
50574 }
50575
50576
50577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50578   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50579   int arg2 ;
50580
50581   arg1 = (Dali::Rect< int > *)jarg1;
50582   arg2 = (int)jarg2;
50583   if (arg1) (arg1)->left = arg2;
50584 }
50585
50586
50587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50588   int jresult ;
50589   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50590   int result;
50591
50592   arg1 = (Dali::Rect< int > *)jarg1;
50593   result = (int) ((arg1)->left);
50594   jresult = result;
50595   return jresult;
50596 }
50597
50598
50599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50600   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50601   int arg2 ;
50602
50603   arg1 = (Dali::Rect< int > *)jarg1;
50604   arg2 = (int)jarg2;
50605   if (arg1) (arg1)->y = arg2;
50606 }
50607
50608
50609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50610   int jresult ;
50611   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50612   int result;
50613
50614   arg1 = (Dali::Rect< int > *)jarg1;
50615   result = (int) ((arg1)->y);
50616   jresult = result;
50617   return jresult;
50618 }
50619
50620
50621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50622   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50623   int arg2 ;
50624
50625   arg1 = (Dali::Rect< int > *)jarg1;
50626   arg2 = (int)jarg2;
50627   if (arg1) (arg1)->right = arg2;
50628 }
50629
50630
50631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50632   int jresult ;
50633   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50634   int result;
50635
50636   arg1 = (Dali::Rect< int > *)jarg1;
50637   result = (int) ((arg1)->right);
50638   jresult = result;
50639   return jresult;
50640 }
50641
50642
50643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50644   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50645   int arg2 ;
50646
50647   arg1 = (Dali::Rect< int > *)jarg1;
50648   arg2 = (int)jarg2;
50649   if (arg1) (arg1)->width = arg2;
50650 }
50651
50652
50653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50654   int jresult ;
50655   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50656   int result;
50657
50658   arg1 = (Dali::Rect< int > *)jarg1;
50659   result = (int) ((arg1)->width);
50660   jresult = result;
50661   return jresult;
50662 }
50663
50664
50665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50666   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50667   int arg2 ;
50668
50669   arg1 = (Dali::Rect< int > *)jarg1;
50670   arg2 = (int)jarg2;
50671   if (arg1) (arg1)->bottom = arg2;
50672 }
50673
50674
50675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50676   int jresult ;
50677   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50678   int result;
50679
50680   arg1 = (Dali::Rect< int > *)jarg1;
50681   result = (int) ((arg1)->bottom);
50682   jresult = result;
50683   return jresult;
50684 }
50685
50686
50687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50688   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50689   int arg2 ;
50690
50691   arg1 = (Dali::Rect< int > *)jarg1;
50692   arg2 = (int)jarg2;
50693   if (arg1) (arg1)->height = arg2;
50694 }
50695
50696
50697 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50698   int jresult ;
50699   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50700   int result;
50701
50702   arg1 = (Dali::Rect< int > *)jarg1;
50703   result = (int) ((arg1)->height);
50704   jresult = result;
50705   return jresult;
50706 }
50707
50708
50709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50710   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50711   int arg2 ;
50712
50713   arg1 = (Dali::Rect< int > *)jarg1;
50714   arg2 = (int)jarg2;
50715   if (arg1) (arg1)->top = arg2;
50716 }
50717
50718
50719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50720   int jresult ;
50721   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50722   int result;
50723
50724   arg1 = (Dali::Rect< int > *)jarg1;
50725   result = (int) ((arg1)->top);
50726   jresult = result;
50727   return jresult;
50728 }
50729
50730
50731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50732   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50733
50734   arg1 = (Dali::Rect< int > *)jarg1;
50735   {
50736     try {
50737       delete arg1;
50738     } catch (std::out_of_range& e) {
50739       {
50740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50741       };
50742     } catch (std::exception& e) {
50743       {
50744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50745       };
50746     } catch (Dali::DaliException e) {
50747       {
50748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50749       };
50750     } catch (...) {
50751       {
50752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50753       };
50754     }
50755   }
50756
50757 }
50758
50759
50760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50761   void * jresult ;
50762   Dali::Rect< float > *result = 0 ;
50763
50764   {
50765     try {
50766       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50767     } catch (std::out_of_range& e) {
50768       {
50769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50770       };
50771     } catch (std::exception& e) {
50772       {
50773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50774       };
50775     } catch (Dali::DaliException e) {
50776       {
50777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50778       };
50779     } catch (...) {
50780       {
50781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50782       };
50783     }
50784   }
50785
50786   jresult = (void *)result;
50787   return jresult;
50788 }
50789
50790
50791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50792   void * jresult ;
50793   float arg1 ;
50794   float arg2 ;
50795   float arg3 ;
50796   float arg4 ;
50797   Dali::Rect< float > *result = 0 ;
50798
50799   arg1 = (float)jarg1;
50800   arg2 = (float)jarg2;
50801   arg3 = (float)jarg4;
50802   arg4 = (float)jarg3;
50803   {
50804     try {
50805       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50806     } catch (std::out_of_range& e) {
50807       {
50808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50809       };
50810     } catch (std::exception& e) {
50811       {
50812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50813       };
50814     } catch (Dali::DaliException e) {
50815       {
50816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50817       };
50818     } catch (...) {
50819       {
50820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50821       };
50822     }
50823   }
50824
50825   jresult = (void *)result;
50826   return jresult;
50827 }
50828
50829
50830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50831   void * jresult ;
50832   Dali::Rect< float > *arg1 = 0 ;
50833   Dali::Rect< float > *result = 0 ;
50834
50835   arg1 = (Dali::Rect< float > *)jarg1;
50836   if (!arg1) {
50837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50838     return 0;
50839   }
50840   {
50841     try {
50842       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50843     } catch (std::out_of_range& e) {
50844       {
50845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50846       };
50847     } catch (std::exception& e) {
50848       {
50849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50850       };
50851     } catch (Dali::DaliException e) {
50852       {
50853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50854       };
50855     } catch (...) {
50856       {
50857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50858       };
50859     }
50860   }
50861
50862   jresult = (void *)result;
50863   return jresult;
50864 }
50865
50866
50867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50868   void * jresult ;
50869   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50870   Dali::Rect< float > *arg2 = 0 ;
50871   Dali::Rect< float > *result = 0 ;
50872
50873   arg1 = (Dali::Rect< float > *)jarg1;
50874   arg2 = (Dali::Rect< float > *)jarg2;
50875   if (!arg2) {
50876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50877     return 0;
50878   }
50879   {
50880     try {
50881       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50882     } catch (std::out_of_range& e) {
50883       {
50884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50885       };
50886     } catch (std::exception& e) {
50887       {
50888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50889       };
50890     } catch (Dali::DaliException e) {
50891       {
50892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50893       };
50894     } catch (...) {
50895       {
50896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50897       };
50898     }
50899   }
50900
50901   jresult = (void *)result;
50902   return jresult;
50903 }
50904
50905
50906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50907   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50908   float arg2 ;
50909   float arg3 ;
50910   float arg4 ;
50911   float arg5 ;
50912
50913   arg1 = (Dali::Rect< float > *)jarg1;
50914   arg2 = (float)jarg2;
50915   arg3 = (float)jarg3;
50916   arg4 = (float)jarg5;
50917   arg5 = (float)jarg4;
50918   {
50919     try {
50920       (arg1)->Set(arg2,arg3,arg4,arg5);
50921     } catch (std::out_of_range& e) {
50922       {
50923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50924       };
50925     } catch (std::exception& e) {
50926       {
50927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50928       };
50929     } catch (Dali::DaliException e) {
50930       {
50931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50932       };
50933     } catch (...) {
50934       {
50935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50936       };
50937     }
50938   }
50939
50940 }
50941
50942
50943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50944   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50945   float arg2 ;
50946
50947   arg1 = (Dali::Rect< float > *)jarg1;
50948   arg2 = (float)jarg2;
50949   if (arg1) (arg1)->left = arg2;
50950 }
50951
50952
50953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50954   float jresult ;
50955   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50956   float result;
50957
50958   arg1 = (Dali::Rect< float > *)jarg1;
50959   result = (float) ((arg1)->left);
50960   jresult = result;
50961   return jresult;
50962 }
50963
50964
50965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50966   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50967   float arg2 ;
50968
50969   arg1 = (Dali::Rect< float > *)jarg1;
50970   arg2 = (float)jarg2;
50971   if (arg1) (arg1)->left = arg2;
50972 }
50973
50974
50975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50976   float jresult ;
50977   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50978   float result;
50979
50980   arg1 = (Dali::Rect< float > *)jarg1;
50981   result = (float) ((arg1)->left);
50982   jresult = result;
50983   return jresult;
50984 }
50985
50986
50987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50988   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50989   float arg2 ;
50990
50991   arg1 = (Dali::Rect< float > *)jarg1;
50992   arg2 = (float)jarg2;
50993   if (arg1) (arg1)->right = arg2;
50994 }
50995
50996
50997 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50998   float jresult ;
50999   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51000   float result;
51001
51002   arg1 = (Dali::Rect< float > *)jarg1;
51003   result = (float) ((arg1)->right);
51004   jresult = result;
51005   return jresult;
51006 }
51007
51008
51009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
51010   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51011   float arg2 ;
51012
51013   arg1 = (Dali::Rect< float > *)jarg1;
51014   arg2 = (float)jarg2;
51015   if (arg1) (arg1)->right = arg2;
51016 }
51017
51018
51019 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
51020   float jresult ;
51021   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51022   float result;
51023
51024   arg1 = (Dali::Rect< float > *)jarg1;
51025   result = (float) ((arg1)->right);
51026   jresult = result;
51027   return jresult;
51028 }
51029
51030
51031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
51032   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51033   float arg2 ;
51034
51035   arg1 = (Dali::Rect< float > *)jarg1;
51036   arg2 = (float)jarg2;
51037   if (arg1) (arg1)->bottom = arg2;
51038 }
51039
51040
51041 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
51042   float jresult ;
51043   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51044   float result;
51045
51046   arg1 = (Dali::Rect< float > *)jarg1;
51047   result = (float) ((arg1)->bottom);
51048   jresult = result;
51049   return jresult;
51050 }
51051
51052
51053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
51054   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51055   float arg2 ;
51056
51057   arg1 = (Dali::Rect< float > *)jarg1;
51058   arg2 = (float)jarg2;
51059   if (arg1) (arg1)->top = arg2;
51060 }
51061
51062
51063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
51064   float jresult ;
51065   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51066   float result;
51067
51068   arg1 = (Dali::Rect< float > *)jarg1;
51069   result = (float) ((arg1)->top);
51070   jresult = result;
51071   return jresult;
51072 }
51073
51074
51075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
51076   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
51077
51078   arg1 = (Dali::Rect< float > *)jarg1;
51079   {
51080     try {
51081       delete arg1;
51082     } catch (std::out_of_range& e) {
51083       {
51084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51085       };
51086     } catch (std::exception& e) {
51087       {
51088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51089       };
51090     } catch (Dali::DaliException e) {
51091       {
51092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51093       };
51094     } catch (...) {
51095       {
51096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51097       };
51098     }
51099   }
51100
51101 }
51102
51103
51104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51105   int jresult ;
51106   int result;
51107
51108   result = (int)Dali::Vector< int >::BaseType;
51109   jresult = (int)result;
51110   return jresult;
51111 }
51112
51113
51114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51115   void * jresult ;
51116   Dali::Vector< int > *result = 0 ;
51117
51118   {
51119     try {
51120       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51121     } catch (std::out_of_range& e) {
51122       {
51123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51124       };
51125     } catch (std::exception& e) {
51126       {
51127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51128       };
51129     } catch (Dali::DaliException e) {
51130       {
51131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51132       };
51133     } catch (...) {
51134       {
51135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51136       };
51137     }
51138   }
51139
51140   jresult = (void *)result;
51141   return jresult;
51142 }
51143
51144
51145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51146   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51147
51148   arg1 = (Dali::Vector< int > *)jarg1;
51149   {
51150     try {
51151       delete arg1;
51152     } catch (std::out_of_range& e) {
51153       {
51154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51155       };
51156     } catch (std::exception& e) {
51157       {
51158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51159       };
51160     } catch (Dali::DaliException e) {
51161       {
51162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51163       };
51164     } catch (...) {
51165       {
51166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51167       };
51168     }
51169   }
51170
51171 }
51172
51173
51174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51175   void * jresult ;
51176   Dali::Vector< int > *arg1 = 0 ;
51177   Dali::Vector< int > *result = 0 ;
51178
51179   arg1 = (Dali::Vector< int > *)jarg1;
51180   if (!arg1) {
51181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51182     return 0;
51183   }
51184   {
51185     try {
51186       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51187     } catch (std::out_of_range& e) {
51188       {
51189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51190       };
51191     } catch (std::exception& e) {
51192       {
51193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51194       };
51195     } catch (Dali::DaliException e) {
51196       {
51197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51198       };
51199     } catch (...) {
51200       {
51201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51202       };
51203     }
51204   }
51205
51206   jresult = (void *)result;
51207   return jresult;
51208 }
51209
51210
51211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51212   void * jresult ;
51213   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51214   Dali::Vector< int > *arg2 = 0 ;
51215   Dali::Vector< int > *result = 0 ;
51216
51217   arg1 = (Dali::Vector< int > *)jarg1;
51218   arg2 = (Dali::Vector< int > *)jarg2;
51219   if (!arg2) {
51220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51221     return 0;
51222   }
51223   {
51224     try {
51225       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51226     } catch (std::out_of_range& e) {
51227       {
51228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51229       };
51230     } catch (std::exception& e) {
51231       {
51232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51233       };
51234     } catch (Dali::DaliException e) {
51235       {
51236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51237       };
51238     } catch (...) {
51239       {
51240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51241       };
51242     }
51243   }
51244
51245   jresult = (void *)result;
51246   return jresult;
51247 }
51248
51249
51250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51251   void * jresult ;
51252   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51253   Dali::Vector< int >::Iterator result;
51254
51255   arg1 = (Dali::Vector< int > *)jarg1;
51256   {
51257     try {
51258       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51259     } catch (std::out_of_range& e) {
51260       {
51261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51262       };
51263     } catch (std::exception& e) {
51264       {
51265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51266       };
51267     } catch (Dali::DaliException e) {
51268       {
51269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51270       };
51271     } catch (...) {
51272       {
51273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51274       };
51275     }
51276   }
51277
51278   jresult = (void *)result;
51279   return jresult;
51280 }
51281
51282
51283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51284   void * jresult ;
51285   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51286   Dali::Vector< int >::Iterator result;
51287
51288   arg1 = (Dali::Vector< int > *)jarg1;
51289   {
51290     try {
51291       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51292     } catch (std::out_of_range& e) {
51293       {
51294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51295       };
51296     } catch (std::exception& e) {
51297       {
51298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51299       };
51300     } catch (Dali::DaliException e) {
51301       {
51302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51303       };
51304     } catch (...) {
51305       {
51306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51307       };
51308     }
51309   }
51310
51311   jresult = (void *)result;
51312   return jresult;
51313 }
51314
51315
51316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51317   void * jresult ;
51318   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51319   Dali::Vector< int >::SizeType arg2 ;
51320   Dali::Vector< int >::ItemType *result = 0 ;
51321
51322   arg1 = (Dali::Vector< int > *)jarg1;
51323   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51324   {
51325     try {
51326       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51327     } catch (std::out_of_range& e) {
51328       {
51329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51330       };
51331     } catch (std::exception& e) {
51332       {
51333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51334       };
51335     } catch (Dali::DaliException e) {
51336       {
51337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51338       };
51339     } catch (...) {
51340       {
51341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51342       };
51343     }
51344   }
51345
51346   jresult = (void *)result;
51347   return jresult;
51348 }
51349
51350
51351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51352   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51353   Dali::Vector< int >::ItemType *arg2 = 0 ;
51354   Dali::Vector< int >::ItemType temp2 ;
51355
51356   arg1 = (Dali::Vector< int > *)jarg1;
51357   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51358   arg2 = &temp2;
51359   {
51360     try {
51361       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51362     } catch (std::out_of_range& e) {
51363       {
51364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51365       };
51366     } catch (std::exception& e) {
51367       {
51368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51369       };
51370     } catch (Dali::DaliException e) {
51371       {
51372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51373       };
51374     } catch (...) {
51375       {
51376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51377       };
51378     }
51379   }
51380
51381 }
51382
51383
51384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51385   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51386   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51387   Dali::Vector< int >::ItemType *arg3 = 0 ;
51388   Dali::Vector< int >::ItemType temp3 ;
51389
51390   arg1 = (Dali::Vector< int > *)jarg1;
51391   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51392   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51393   arg3 = &temp3;
51394   {
51395     try {
51396       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51397     } catch (std::out_of_range& e) {
51398       {
51399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51400       };
51401     } catch (std::exception& e) {
51402       {
51403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51404       };
51405     } catch (Dali::DaliException e) {
51406       {
51407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51408       };
51409     } catch (...) {
51410       {
51411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51412       };
51413     }
51414   }
51415
51416 }
51417
51418
51419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51420   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51421   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51422   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51423   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51424
51425   arg1 = (Dali::Vector< int > *)jarg1;
51426   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51427   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51428   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51429   {
51430     try {
51431       (arg1)->Insert(arg2,arg3,arg4);
51432     } catch (std::out_of_range& e) {
51433       {
51434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51435       };
51436     } catch (std::exception& e) {
51437       {
51438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51439       };
51440     } catch (Dali::DaliException e) {
51441       {
51442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51443       };
51444     } catch (...) {
51445       {
51446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51447       };
51448     }
51449   }
51450
51451 }
51452
51453
51454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51455   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51456   Dali::Vector< int >::SizeType arg2 ;
51457
51458   arg1 = (Dali::Vector< int > *)jarg1;
51459   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51460   {
51461     try {
51462       (arg1)->Reserve(arg2);
51463     } catch (std::out_of_range& e) {
51464       {
51465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51466       };
51467     } catch (std::exception& e) {
51468       {
51469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51470       };
51471     } catch (Dali::DaliException e) {
51472       {
51473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51474       };
51475     } catch (...) {
51476       {
51477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51478       };
51479     }
51480   }
51481
51482 }
51483
51484
51485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51486   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51487   Dali::Vector< int >::SizeType arg2 ;
51488
51489   arg1 = (Dali::Vector< int > *)jarg1;
51490   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51491   {
51492     try {
51493       (arg1)->Resize(arg2);
51494     } catch (std::out_of_range& e) {
51495       {
51496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51497       };
51498     } catch (std::exception& e) {
51499       {
51500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51501       };
51502     } catch (Dali::DaliException e) {
51503       {
51504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51505       };
51506     } catch (...) {
51507       {
51508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51509       };
51510     }
51511   }
51512
51513 }
51514
51515
51516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51517   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51518   Dali::Vector< int >::SizeType arg2 ;
51519   Dali::Vector< int >::ItemType *arg3 = 0 ;
51520   Dali::Vector< int >::ItemType temp3 ;
51521
51522   arg1 = (Dali::Vector< int > *)jarg1;
51523   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51524   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51525   arg3 = &temp3;
51526   {
51527     try {
51528       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51529     } catch (std::out_of_range& e) {
51530       {
51531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51532       };
51533     } catch (std::exception& e) {
51534       {
51535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51536       };
51537     } catch (Dali::DaliException e) {
51538       {
51539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51540       };
51541     } catch (...) {
51542       {
51543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51544       };
51545     }
51546   }
51547
51548 }
51549
51550
51551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51552   void * jresult ;
51553   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51554   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51555   Dali::Vector< int >::Iterator result;
51556
51557   arg1 = (Dali::Vector< int > *)jarg1;
51558   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51559   {
51560     try {
51561       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51562     } catch (std::out_of_range& e) {
51563       {
51564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51565       };
51566     } catch (std::exception& e) {
51567       {
51568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51569       };
51570     } catch (Dali::DaliException e) {
51571       {
51572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51573       };
51574     } catch (...) {
51575       {
51576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51577       };
51578     }
51579   }
51580
51581   jresult = (void *)result;
51582   return jresult;
51583 }
51584
51585
51586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51587   void * jresult ;
51588   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51589   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51590   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51591   Dali::Vector< int >::Iterator result;
51592
51593   arg1 = (Dali::Vector< int > *)jarg1;
51594   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51595   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51596   {
51597     try {
51598       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51599     } catch (std::out_of_range& e) {
51600       {
51601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51602       };
51603     } catch (std::exception& e) {
51604       {
51605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51606       };
51607     } catch (Dali::DaliException e) {
51608       {
51609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51610       };
51611     } catch (...) {
51612       {
51613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51614       };
51615     }
51616   }
51617
51618   jresult = (void *)result;
51619   return jresult;
51620 }
51621
51622
51623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51624   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51625   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51626
51627   arg1 = (Dali::Vector< int > *)jarg1;
51628   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51629   {
51630     try {
51631       (arg1)->Remove(arg2);
51632     } catch (std::out_of_range& e) {
51633       {
51634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51635       };
51636     } catch (std::exception& e) {
51637       {
51638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51639       };
51640     } catch (Dali::DaliException e) {
51641       {
51642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51643       };
51644     } catch (...) {
51645       {
51646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51647       };
51648     }
51649   }
51650
51651 }
51652
51653
51654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51655   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51656   Dali::Vector< int > *arg2 = 0 ;
51657
51658   arg1 = (Dali::Vector< int > *)jarg1;
51659   arg2 = (Dali::Vector< int > *)jarg2;
51660   if (!arg2) {
51661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51662     return ;
51663   }
51664   {
51665     try {
51666       (arg1)->Swap(*arg2);
51667     } catch (std::out_of_range& e) {
51668       {
51669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51670       };
51671     } catch (std::exception& e) {
51672       {
51673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51674       };
51675     } catch (Dali::DaliException e) {
51676       {
51677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51678       };
51679     } catch (...) {
51680       {
51681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51682       };
51683     }
51684   }
51685
51686 }
51687
51688
51689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51690   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51691
51692   arg1 = (Dali::Vector< int > *)jarg1;
51693   {
51694     try {
51695       (arg1)->Clear();
51696     } catch (std::out_of_range& e) {
51697       {
51698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51699       };
51700     } catch (std::exception& e) {
51701       {
51702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51703       };
51704     } catch (Dali::DaliException e) {
51705       {
51706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51707       };
51708     } catch (...) {
51709       {
51710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51711       };
51712     }
51713   }
51714
51715 }
51716
51717
51718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51719   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51720
51721   arg1 = (Dali::Vector< int > *)jarg1;
51722   {
51723     try {
51724       (arg1)->Release();
51725     } catch (std::out_of_range& e) {
51726       {
51727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51728       };
51729     } catch (std::exception& e) {
51730       {
51731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51732       };
51733     } catch (Dali::DaliException e) {
51734       {
51735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51736       };
51737     } catch (...) {
51738       {
51739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51740       };
51741     }
51742   }
51743
51744 }
51745
51746
51747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51748   int jresult ;
51749   int result;
51750
51751   result = (int)Dali::Vector< float >::BaseType;
51752   jresult = (int)result;
51753   return jresult;
51754 }
51755
51756
51757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51758   void * jresult ;
51759   Dali::Vector< float > *result = 0 ;
51760
51761   {
51762     try {
51763       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51764     } catch (std::out_of_range& e) {
51765       {
51766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51767       };
51768     } catch (std::exception& e) {
51769       {
51770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51771       };
51772     } catch (Dali::DaliException e) {
51773       {
51774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51775       };
51776     } catch (...) {
51777       {
51778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51779       };
51780     }
51781   }
51782
51783   jresult = (void *)result;
51784   return jresult;
51785 }
51786
51787
51788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51789   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51790
51791   arg1 = (Dali::Vector< float > *)jarg1;
51792   {
51793     try {
51794       delete arg1;
51795     } catch (std::out_of_range& e) {
51796       {
51797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51798       };
51799     } catch (std::exception& e) {
51800       {
51801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51802       };
51803     } catch (Dali::DaliException e) {
51804       {
51805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51806       };
51807     } catch (...) {
51808       {
51809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51810       };
51811     }
51812   }
51813
51814 }
51815
51816
51817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51818   void * jresult ;
51819   Dali::Vector< float > *arg1 = 0 ;
51820   Dali::Vector< float > *result = 0 ;
51821
51822   arg1 = (Dali::Vector< float > *)jarg1;
51823   if (!arg1) {
51824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51825     return 0;
51826   }
51827   {
51828     try {
51829       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51830     } catch (std::out_of_range& e) {
51831       {
51832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51833       };
51834     } catch (std::exception& e) {
51835       {
51836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51837       };
51838     } catch (Dali::DaliException e) {
51839       {
51840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51841       };
51842     } catch (...) {
51843       {
51844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51845       };
51846     }
51847   }
51848
51849   jresult = (void *)result;
51850   return jresult;
51851 }
51852
51853
51854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51855   void * jresult ;
51856   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51857   Dali::Vector< float > *arg2 = 0 ;
51858   Dali::Vector< float > *result = 0 ;
51859
51860   arg1 = (Dali::Vector< float > *)jarg1;
51861   arg2 = (Dali::Vector< float > *)jarg2;
51862   if (!arg2) {
51863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51864     return 0;
51865   }
51866   {
51867     try {
51868       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51869     } catch (std::out_of_range& e) {
51870       {
51871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51872       };
51873     } catch (std::exception& e) {
51874       {
51875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51876       };
51877     } catch (Dali::DaliException e) {
51878       {
51879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51880       };
51881     } catch (...) {
51882       {
51883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51884       };
51885     }
51886   }
51887
51888   jresult = (void *)result;
51889   return jresult;
51890 }
51891
51892
51893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51894   void * jresult ;
51895   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51896   Dali::Vector< float >::Iterator result;
51897
51898   arg1 = (Dali::Vector< float > *)jarg1;
51899   {
51900     try {
51901       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51902     } catch (std::out_of_range& e) {
51903       {
51904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51905       };
51906     } catch (std::exception& e) {
51907       {
51908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51909       };
51910     } catch (Dali::DaliException e) {
51911       {
51912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51913       };
51914     } catch (...) {
51915       {
51916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51917       };
51918     }
51919   }
51920
51921   jresult = (void *)result;
51922   return jresult;
51923 }
51924
51925
51926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51927   void * jresult ;
51928   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51929   Dali::Vector< float >::Iterator result;
51930
51931   arg1 = (Dali::Vector< float > *)jarg1;
51932   {
51933     try {
51934       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51935     } catch (std::out_of_range& e) {
51936       {
51937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51938       };
51939     } catch (std::exception& e) {
51940       {
51941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51942       };
51943     } catch (Dali::DaliException e) {
51944       {
51945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51946       };
51947     } catch (...) {
51948       {
51949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51950       };
51951     }
51952   }
51953
51954   jresult = (void *)result;
51955   return jresult;
51956 }
51957
51958
51959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51960   void * jresult ;
51961   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51962   Dali::Vector< float >::SizeType arg2 ;
51963   Dali::Vector< float >::ItemType *result = 0 ;
51964
51965   arg1 = (Dali::Vector< float > *)jarg1;
51966   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51967   {
51968     try {
51969       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51970     } catch (std::out_of_range& e) {
51971       {
51972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51973       };
51974     } catch (std::exception& e) {
51975       {
51976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51977       };
51978     } catch (Dali::DaliException e) {
51979       {
51980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51981       };
51982     } catch (...) {
51983       {
51984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51985       };
51986     }
51987   }
51988
51989   jresult = (void *)result;
51990   return jresult;
51991 }
51992
51993
51994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51995   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51996   Dali::Vector< float >::ItemType *arg2 = 0 ;
51997   Dali::Vector< float >::ItemType temp2 ;
51998
51999   arg1 = (Dali::Vector< float > *)jarg1;
52000   temp2 = (Dali::Vector< float >::ItemType)jarg2;
52001   arg2 = &temp2;
52002   {
52003     try {
52004       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
52005     } catch (std::out_of_range& e) {
52006       {
52007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52008       };
52009     } catch (std::exception& e) {
52010       {
52011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52012       };
52013     } catch (Dali::DaliException e) {
52014       {
52015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52016       };
52017     } catch (...) {
52018       {
52019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52020       };
52021     }
52022   }
52023
52024 }
52025
52026
52027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
52028   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52029   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52030   Dali::Vector< float >::ItemType *arg3 = 0 ;
52031   Dali::Vector< float >::ItemType temp3 ;
52032
52033   arg1 = (Dali::Vector< float > *)jarg1;
52034   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52035   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52036   arg3 = &temp3;
52037   {
52038     try {
52039       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52040     } catch (std::out_of_range& e) {
52041       {
52042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52043       };
52044     } catch (std::exception& e) {
52045       {
52046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52047       };
52048     } catch (Dali::DaliException e) {
52049       {
52050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52051       };
52052     } catch (...) {
52053       {
52054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52055       };
52056     }
52057   }
52058
52059 }
52060
52061
52062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52063   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52064   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52065   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52066   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
52067
52068   arg1 = (Dali::Vector< float > *)jarg1;
52069   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52070   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52071   arg4 = (Dali::Vector< float >::Iterator)jarg4;
52072   {
52073     try {
52074       (arg1)->Insert(arg2,arg3,arg4);
52075     } catch (std::out_of_range& e) {
52076       {
52077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52078       };
52079     } catch (std::exception& e) {
52080       {
52081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52082       };
52083     } catch (Dali::DaliException e) {
52084       {
52085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52086       };
52087     } catch (...) {
52088       {
52089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52090       };
52091     }
52092   }
52093
52094 }
52095
52096
52097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52098   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52099   Dali::Vector< float >::SizeType arg2 ;
52100
52101   arg1 = (Dali::Vector< float > *)jarg1;
52102   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52103   {
52104     try {
52105       (arg1)->Reserve(arg2);
52106     } catch (std::out_of_range& e) {
52107       {
52108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52109       };
52110     } catch (std::exception& e) {
52111       {
52112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52113       };
52114     } catch (Dali::DaliException e) {
52115       {
52116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52117       };
52118     } catch (...) {
52119       {
52120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52121       };
52122     }
52123   }
52124
52125 }
52126
52127 //// ========================= end of part 2 =============================
52128
52129 //// ========================== start part 3 ===============================
52130
52131
52132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52133   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52134   Dali::Vector< float >::SizeType arg2 ;
52135
52136   arg1 = (Dali::Vector< float > *)jarg1;
52137   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52138   {
52139     try {
52140       (arg1)->Resize(arg2);
52141     } catch (std::out_of_range& e) {
52142       {
52143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52144       };
52145     } catch (std::exception& e) {
52146       {
52147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52148       };
52149     } catch (Dali::DaliException e) {
52150       {
52151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52152       };
52153     } catch (...) {
52154       {
52155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52156       };
52157     }
52158   }
52159
52160 }
52161
52162
52163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52164   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52165   Dali::Vector< float >::SizeType arg2 ;
52166   Dali::Vector< float >::ItemType *arg3 = 0 ;
52167   Dali::Vector< float >::ItemType temp3 ;
52168
52169   arg1 = (Dali::Vector< float > *)jarg1;
52170   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52171   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52172   arg3 = &temp3;
52173   {
52174     try {
52175       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52176     } catch (std::out_of_range& e) {
52177       {
52178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52179       };
52180     } catch (std::exception& e) {
52181       {
52182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52183       };
52184     } catch (Dali::DaliException e) {
52185       {
52186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52187       };
52188     } catch (...) {
52189       {
52190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52191       };
52192     }
52193   }
52194
52195 }
52196
52197
52198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52199   void * jresult ;
52200   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52201   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52202   Dali::Vector< float >::Iterator result;
52203
52204   arg1 = (Dali::Vector< float > *)jarg1;
52205   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52206   {
52207     try {
52208       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52209     } catch (std::out_of_range& e) {
52210       {
52211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52212       };
52213     } catch (std::exception& e) {
52214       {
52215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52216       };
52217     } catch (Dali::DaliException e) {
52218       {
52219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52220       };
52221     } catch (...) {
52222       {
52223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52224       };
52225     }
52226   }
52227
52228   jresult = (void *)result;
52229   return jresult;
52230 }
52231
52232
52233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52234   void * jresult ;
52235   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52236   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52237   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52238   Dali::Vector< float >::Iterator result;
52239
52240   arg1 = (Dali::Vector< float > *)jarg1;
52241   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52242   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52243   {
52244     try {
52245       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52246     } catch (std::out_of_range& e) {
52247       {
52248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52249       };
52250     } catch (std::exception& e) {
52251       {
52252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52253       };
52254     } catch (Dali::DaliException e) {
52255       {
52256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52257       };
52258     } catch (...) {
52259       {
52260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52261       };
52262     }
52263   }
52264
52265   jresult = (void *)result;
52266   return jresult;
52267 }
52268
52269
52270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52271   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52272   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52273
52274   arg1 = (Dali::Vector< float > *)jarg1;
52275   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52276   {
52277     try {
52278       (arg1)->Remove(arg2);
52279     } catch (std::out_of_range& e) {
52280       {
52281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52282       };
52283     } catch (std::exception& e) {
52284       {
52285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52286       };
52287     } catch (Dali::DaliException e) {
52288       {
52289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52290       };
52291     } catch (...) {
52292       {
52293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52294       };
52295     }
52296   }
52297
52298 }
52299
52300
52301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52302   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52303   Dali::Vector< float > *arg2 = 0 ;
52304
52305   arg1 = (Dali::Vector< float > *)jarg1;
52306   arg2 = (Dali::Vector< float > *)jarg2;
52307   if (!arg2) {
52308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52309     return ;
52310   }
52311   {
52312     try {
52313       (arg1)->Swap(*arg2);
52314     } catch (std::out_of_range& e) {
52315       {
52316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52317       };
52318     } catch (std::exception& e) {
52319       {
52320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52321       };
52322     } catch (Dali::DaliException e) {
52323       {
52324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52325       };
52326     } catch (...) {
52327       {
52328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52329       };
52330     }
52331   }
52332
52333 }
52334
52335
52336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52337   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52338
52339   arg1 = (Dali::Vector< float > *)jarg1;
52340   {
52341     try {
52342       (arg1)->Clear();
52343     } catch (std::out_of_range& e) {
52344       {
52345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52346       };
52347     } catch (std::exception& e) {
52348       {
52349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52350       };
52351     } catch (Dali::DaliException e) {
52352       {
52353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52354       };
52355     } catch (...) {
52356       {
52357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52358       };
52359     }
52360   }
52361
52362 }
52363
52364
52365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52366   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52367
52368   arg1 = (Dali::Vector< float > *)jarg1;
52369   {
52370     try {
52371       (arg1)->Release();
52372     } catch (std::out_of_range& e) {
52373       {
52374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52375       };
52376     } catch (std::exception& e) {
52377       {
52378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52379       };
52380     } catch (Dali::DaliException e) {
52381       {
52382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52383       };
52384     } catch (...) {
52385       {
52386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52387       };
52388     }
52389   }
52390
52391 }
52392
52393
52394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52395   int jresult ;
52396   int result;
52397
52398   result = (int)Dali::Vector< unsigned char >::BaseType;
52399   jresult = (int)result;
52400   return jresult;
52401 }
52402
52403
52404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52405   void * jresult ;
52406   Dali::Vector< unsigned char > *result = 0 ;
52407
52408   {
52409     try {
52410       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52411     } catch (std::out_of_range& e) {
52412       {
52413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52414       };
52415     } catch (std::exception& e) {
52416       {
52417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52418       };
52419     } catch (Dali::DaliException e) {
52420       {
52421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52422       };
52423     } catch (...) {
52424       {
52425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52426       };
52427     }
52428   }
52429
52430   jresult = (void *)result;
52431   return jresult;
52432 }
52433
52434
52435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52436   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52437
52438   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52439   {
52440     try {
52441       delete arg1;
52442     } catch (std::out_of_range& e) {
52443       {
52444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52445       };
52446     } catch (std::exception& e) {
52447       {
52448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52449       };
52450     } catch (Dali::DaliException e) {
52451       {
52452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52453       };
52454     } catch (...) {
52455       {
52456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52457       };
52458     }
52459   }
52460
52461 }
52462
52463
52464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52465   void * jresult ;
52466   Dali::Vector< unsigned char > *arg1 = 0 ;
52467   Dali::Vector< unsigned char > *result = 0 ;
52468
52469   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52470   if (!arg1) {
52471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52472     return 0;
52473   }
52474   {
52475     try {
52476       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52477     } catch (std::out_of_range& e) {
52478       {
52479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52480       };
52481     } catch (std::exception& e) {
52482       {
52483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52484       };
52485     } catch (Dali::DaliException e) {
52486       {
52487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52488       };
52489     } catch (...) {
52490       {
52491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52492       };
52493     }
52494   }
52495
52496   jresult = (void *)result;
52497   return jresult;
52498 }
52499
52500
52501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52502   void * jresult ;
52503   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52504   Dali::Vector< unsigned char > *arg2 = 0 ;
52505   Dali::Vector< unsigned char > *result = 0 ;
52506
52507   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52508   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52509   if (!arg2) {
52510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52511     return 0;
52512   }
52513   {
52514     try {
52515       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52516     } catch (std::out_of_range& e) {
52517       {
52518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52519       };
52520     } catch (std::exception& e) {
52521       {
52522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52523       };
52524     } catch (Dali::DaliException e) {
52525       {
52526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52527       };
52528     } catch (...) {
52529       {
52530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52531       };
52532     }
52533   }
52534
52535   jresult = (void *)result;
52536   return jresult;
52537 }
52538
52539
52540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52541   void * jresult ;
52542   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52543   Dali::Vector< unsigned char >::Iterator result;
52544
52545   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52546   {
52547     try {
52548       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52549     } catch (std::out_of_range& e) {
52550       {
52551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52552       };
52553     } catch (std::exception& e) {
52554       {
52555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52556       };
52557     } catch (Dali::DaliException e) {
52558       {
52559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52560       };
52561     } catch (...) {
52562       {
52563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52564       };
52565     }
52566   }
52567
52568   jresult = (void *)result;
52569   return jresult;
52570 }
52571
52572
52573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52574   void * jresult ;
52575   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52576   Dali::Vector< unsigned char >::Iterator result;
52577
52578   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52579   {
52580     try {
52581       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52582     } catch (std::out_of_range& e) {
52583       {
52584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52585       };
52586     } catch (std::exception& e) {
52587       {
52588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52589       };
52590     } catch (Dali::DaliException e) {
52591       {
52592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52593       };
52594     } catch (...) {
52595       {
52596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52597       };
52598     }
52599   }
52600
52601   jresult = (void *)result;
52602   return jresult;
52603 }
52604
52605
52606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52607   void * jresult ;
52608   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52609   Dali::Vector< unsigned char >::SizeType arg2 ;
52610   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52611
52612   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52613   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52614   {
52615     try {
52616       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52617     } catch (std::out_of_range& e) {
52618       {
52619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52620       };
52621     } catch (std::exception& e) {
52622       {
52623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52624       };
52625     } catch (Dali::DaliException e) {
52626       {
52627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52628       };
52629     } catch (...) {
52630       {
52631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52632       };
52633     }
52634   }
52635
52636   jresult = (void *)result;
52637   return jresult;
52638 }
52639
52640
52641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52642   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52643   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52644   Dali::Vector< unsigned char >::ItemType temp2 ;
52645
52646   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52647   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52648   arg2 = &temp2;
52649   {
52650     try {
52651       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52652     } catch (std::out_of_range& e) {
52653       {
52654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52655       };
52656     } catch (std::exception& e) {
52657       {
52658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52659       };
52660     } catch (Dali::DaliException e) {
52661       {
52662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52663       };
52664     } catch (...) {
52665       {
52666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52667       };
52668     }
52669   }
52670
52671 }
52672
52673
52674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52675   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52676   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52677   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52678   Dali::Vector< unsigned char >::ItemType temp3 ;
52679
52680   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52681   arg2 = jarg2;
52682   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52683   arg3 = &temp3;
52684   {
52685     try {
52686       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52687     } catch (std::out_of_range& e) {
52688       {
52689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52690       };
52691     } catch (std::exception& e) {
52692       {
52693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52694       };
52695     } catch (Dali::DaliException e) {
52696       {
52697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52698       };
52699     } catch (...) {
52700       {
52701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52702       };
52703     }
52704   }
52705
52706
52707
52708 }
52709
52710
52711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52712   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52713   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52714   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52715   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52716
52717   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52718   arg2 = jarg2;
52719   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52720   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52721   {
52722     try {
52723       (arg1)->Insert(arg2,arg3,arg4);
52724     } catch (std::out_of_range& e) {
52725       {
52726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52727       };
52728     } catch (std::exception& e) {
52729       {
52730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52731       };
52732     } catch (Dali::DaliException e) {
52733       {
52734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52735       };
52736     } catch (...) {
52737       {
52738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52739       };
52740     }
52741   }
52742
52743
52744
52745 }
52746
52747
52748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52749   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52750   Dali::Vector< unsigned char >::SizeType arg2 ;
52751
52752   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52753   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52754   {
52755     try {
52756       (arg1)->Reserve(arg2);
52757     } catch (std::out_of_range& e) {
52758       {
52759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52760       };
52761     } catch (std::exception& e) {
52762       {
52763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52764       };
52765     } catch (Dali::DaliException e) {
52766       {
52767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52768       };
52769     } catch (...) {
52770       {
52771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52772       };
52773     }
52774   }
52775
52776 }
52777
52778
52779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52780   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52781   Dali::Vector< unsigned char >::SizeType arg2 ;
52782
52783   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52784   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52785   {
52786     try {
52787       (arg1)->Resize(arg2);
52788     } catch (std::out_of_range& e) {
52789       {
52790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52791       };
52792     } catch (std::exception& e) {
52793       {
52794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52795       };
52796     } catch (Dali::DaliException e) {
52797       {
52798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52799       };
52800     } catch (...) {
52801       {
52802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52803       };
52804     }
52805   }
52806
52807 }
52808
52809
52810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52811   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52812   Dali::Vector< unsigned char >::SizeType arg2 ;
52813   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52814   Dali::Vector< unsigned char >::ItemType temp3 ;
52815
52816   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52817   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52818   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52819   arg3 = &temp3;
52820   {
52821     try {
52822       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52823     } catch (std::out_of_range& e) {
52824       {
52825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52826       };
52827     } catch (std::exception& e) {
52828       {
52829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52830       };
52831     } catch (Dali::DaliException e) {
52832       {
52833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52834       };
52835     } catch (...) {
52836       {
52837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52838       };
52839     }
52840   }
52841
52842 }
52843
52844
52845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52846   void * jresult ;
52847   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52848   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52849   Dali::Vector< unsigned char >::Iterator result;
52850
52851   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52852   arg2 = jarg2;
52853   {
52854     try {
52855       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52856     } catch (std::out_of_range& e) {
52857       {
52858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52859       };
52860     } catch (std::exception& e) {
52861       {
52862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52863       };
52864     } catch (Dali::DaliException e) {
52865       {
52866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52867       };
52868     } catch (...) {
52869       {
52870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52871       };
52872     }
52873   }
52874
52875   jresult = (void *)result;
52876
52877
52878   return jresult;
52879 }
52880
52881
52882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52883   void * jresult ;
52884   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52885   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52886   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52887   Dali::Vector< unsigned char >::Iterator result;
52888
52889   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52890   arg2 = jarg2;
52891   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52892   {
52893     try {
52894       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52895     } catch (std::out_of_range& e) {
52896       {
52897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52898       };
52899     } catch (std::exception& e) {
52900       {
52901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52902       };
52903     } catch (Dali::DaliException e) {
52904       {
52905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52906       };
52907     } catch (...) {
52908       {
52909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52910       };
52911     }
52912   }
52913
52914   jresult = (void *)result;
52915
52916
52917   return jresult;
52918 }
52919
52920
52921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52922   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52923   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52924
52925   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52926   arg2 = jarg2;
52927   {
52928     try {
52929       (arg1)->Remove(arg2);
52930     } catch (std::out_of_range& e) {
52931       {
52932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52933       };
52934     } catch (std::exception& e) {
52935       {
52936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52937       };
52938     } catch (Dali::DaliException e) {
52939       {
52940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52941       };
52942     } catch (...) {
52943       {
52944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52945       };
52946     }
52947   }
52948
52949
52950
52951 }
52952
52953
52954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52955   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52956   Dali::Vector< unsigned char > *arg2 = 0 ;
52957
52958   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52959   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52960   if (!arg2) {
52961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52962     return ;
52963   }
52964   {
52965     try {
52966       (arg1)->Swap(*arg2);
52967     } catch (std::out_of_range& e) {
52968       {
52969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52970       };
52971     } catch (std::exception& e) {
52972       {
52973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52974       };
52975     } catch (Dali::DaliException e) {
52976       {
52977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52978       };
52979     } catch (...) {
52980       {
52981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52982       };
52983     }
52984   }
52985
52986 }
52987
52988
52989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52990   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52991
52992   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52993   {
52994     try {
52995       (arg1)->Clear();
52996     } catch (std::out_of_range& e) {
52997       {
52998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52999       };
53000     } catch (std::exception& e) {
53001       {
53002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53003       };
53004     } catch (Dali::DaliException e) {
53005       {
53006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53007       };
53008     } catch (...) {
53009       {
53010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53011       };
53012     }
53013   }
53014
53015 }
53016
53017
53018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
53019   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
53020
53021   arg1 = (Dali::Vector< unsigned char > *)jarg1;
53022   {
53023     try {
53024       (arg1)->Release();
53025     } catch (std::out_of_range& e) {
53026       {
53027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53028       };
53029     } catch (std::exception& e) {
53030       {
53031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53032       };
53033     } catch (Dali::DaliException e) {
53034       {
53035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53036       };
53037     } catch (...) {
53038       {
53039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53040       };
53041     }
53042   }
53043
53044 }
53045
53046
53047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
53048   int jresult ;
53049   int result;
53050
53051   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
53052   jresult = (int)result;
53053   return jresult;
53054 }
53055
53056
53057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
53058   void * jresult ;
53059   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53060
53061   {
53062     try {
53063       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
53064     } catch (std::out_of_range& e) {
53065       {
53066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53067       };
53068     } catch (std::exception& e) {
53069       {
53070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53071       };
53072     } catch (Dali::DaliException e) {
53073       {
53074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53075       };
53076     } catch (...) {
53077       {
53078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53079       };
53080     }
53081   }
53082
53083   jresult = (void *)result;
53084   return jresult;
53085 }
53086
53087
53088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53089   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53090
53091   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53092   {
53093     try {
53094       delete arg1;
53095     } catch (std::out_of_range& e) {
53096       {
53097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53098       };
53099     } catch (std::exception& e) {
53100       {
53101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53102       };
53103     } catch (Dali::DaliException e) {
53104       {
53105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53106       };
53107     } catch (...) {
53108       {
53109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53110       };
53111     }
53112   }
53113
53114 }
53115
53116
53117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53118   void * jresult ;
53119   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53120   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53121
53122   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53123   if (!arg1) {
53124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53125     return 0;
53126   }
53127   {
53128     try {
53129       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53130     } catch (std::out_of_range& e) {
53131       {
53132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53133       };
53134     } catch (std::exception& e) {
53135       {
53136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53137       };
53138     } catch (Dali::DaliException e) {
53139       {
53140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53141       };
53142     } catch (...) {
53143       {
53144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53145       };
53146     }
53147   }
53148
53149   jresult = (void *)result;
53150   return jresult;
53151 }
53152
53153
53154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53155   void * jresult ;
53156   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53157   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53158   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53159
53160   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53161   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53162   if (!arg2) {
53163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53164     return 0;
53165   }
53166   {
53167     try {
53168       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53169     } catch (std::out_of_range& e) {
53170       {
53171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53172       };
53173     } catch (std::exception& e) {
53174       {
53175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53176       };
53177     } catch (Dali::DaliException e) {
53178       {
53179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53180       };
53181     } catch (...) {
53182       {
53183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53184       };
53185     }
53186   }
53187
53188   jresult = (void *)result;
53189   return jresult;
53190 }
53191
53192
53193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53194   void * jresult ;
53195   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53196   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53197
53198   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53199   {
53200     try {
53201       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53202     } catch (std::out_of_range& e) {
53203       {
53204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53205       };
53206     } catch (std::exception& e) {
53207       {
53208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53209       };
53210     } catch (Dali::DaliException e) {
53211       {
53212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53213       };
53214     } catch (...) {
53215       {
53216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53217       };
53218     }
53219   }
53220
53221   jresult = (void *)result;
53222   return jresult;
53223 }
53224
53225
53226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53227   void * jresult ;
53228   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53229   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53230
53231   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53232   {
53233     try {
53234       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53235     } catch (std::out_of_range& e) {
53236       {
53237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53238       };
53239     } catch (std::exception& e) {
53240       {
53241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53242       };
53243     } catch (Dali::DaliException e) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53246       };
53247     } catch (...) {
53248       {
53249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53250       };
53251     }
53252   }
53253
53254   jresult = (void *)result;
53255   return jresult;
53256 }
53257
53258
53259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53260   void * jresult ;
53261   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53262   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53263   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53264
53265   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53266   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53267   {
53268     try {
53269       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53270     } catch (std::out_of_range& e) {
53271       {
53272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53273       };
53274     } catch (std::exception& e) {
53275       {
53276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53277       };
53278     } catch (Dali::DaliException e) {
53279       {
53280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53281       };
53282     } catch (...) {
53283       {
53284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53285       };
53286     }
53287   }
53288
53289   jresult = (void *)result;
53290   return jresult;
53291 }
53292
53293
53294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53295   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53296   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53297
53298   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53299   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53300   if (!arg2) {
53301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53302     return ;
53303   }
53304   {
53305     try {
53306       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53307     } catch (std::out_of_range& e) {
53308       {
53309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53310       };
53311     } catch (std::exception& e) {
53312       {
53313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53314       };
53315     } catch (Dali::DaliException e) {
53316       {
53317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53318       };
53319     } catch (...) {
53320       {
53321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53322       };
53323     }
53324   }
53325
53326 }
53327
53328
53329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53330   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53331   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53332   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53333
53334   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53335   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53336   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53337   if (!arg3) {
53338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53339     return ;
53340   }
53341   {
53342     try {
53343       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53344     } catch (std::out_of_range& e) {
53345       {
53346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53347       };
53348     } catch (std::exception& e) {
53349       {
53350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53351       };
53352     } catch (Dali::DaliException e) {
53353       {
53354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53355       };
53356     } catch (...) {
53357       {
53358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53359       };
53360     }
53361   }
53362
53363 }
53364
53365
53366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53367   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53368   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53369   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53370   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53371
53372   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53373   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53374   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53375   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53376   {
53377     try {
53378       (arg1)->Insert(arg2,arg3,arg4);
53379     } catch (std::out_of_range& e) {
53380       {
53381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53382       };
53383     } catch (std::exception& e) {
53384       {
53385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53386       };
53387     } catch (Dali::DaliException e) {
53388       {
53389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53390       };
53391     } catch (...) {
53392       {
53393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53394       };
53395     }
53396   }
53397
53398 }
53399
53400
53401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53402   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53403   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53404
53405   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53406   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53407   {
53408     try {
53409       (arg1)->Reserve(arg2);
53410     } catch (std::out_of_range& e) {
53411       {
53412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53413       };
53414     } catch (std::exception& e) {
53415       {
53416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53417       };
53418     } catch (Dali::DaliException e) {
53419       {
53420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53421       };
53422     } catch (...) {
53423       {
53424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53425       };
53426     }
53427   }
53428
53429 }
53430
53431
53432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53433   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53434   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53435
53436   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53437   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53438   {
53439     try {
53440       (arg1)->Resize(arg2);
53441     } catch (std::out_of_range& e) {
53442       {
53443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53444       };
53445     } catch (std::exception& e) {
53446       {
53447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53448       };
53449     } catch (Dali::DaliException e) {
53450       {
53451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53452       };
53453     } catch (...) {
53454       {
53455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53456       };
53457     }
53458   }
53459
53460 }
53461
53462
53463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53464   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53465   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53466   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53467
53468   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53469   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53470   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53471   if (!arg3) {
53472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53473     return ;
53474   }
53475   {
53476     try {
53477       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53478     } catch (std::out_of_range& e) {
53479       {
53480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53481       };
53482     } catch (std::exception& e) {
53483       {
53484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53485       };
53486     } catch (Dali::DaliException e) {
53487       {
53488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53489       };
53490     } catch (...) {
53491       {
53492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53493       };
53494     }
53495   }
53496
53497 }
53498
53499
53500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53501   void * jresult ;
53502   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53503   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53504   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53505
53506   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53507   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53508   {
53509     try {
53510       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53511     } catch (std::out_of_range& e) {
53512       {
53513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53514       };
53515     } catch (std::exception& e) {
53516       {
53517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53518       };
53519     } catch (Dali::DaliException e) {
53520       {
53521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53522       };
53523     } catch (...) {
53524       {
53525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53526       };
53527     }
53528   }
53529
53530   jresult = (void *)result;
53531   return jresult;
53532 }
53533
53534
53535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53536   void * jresult ;
53537   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53538   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53539   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53540   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53541
53542   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53543   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53544   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53545   {
53546     try {
53547       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53548     } catch (std::out_of_range& e) {
53549       {
53550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53551       };
53552     } catch (std::exception& e) {
53553       {
53554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53555       };
53556     } catch (Dali::DaliException e) {
53557       {
53558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53559       };
53560     } catch (...) {
53561       {
53562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53563       };
53564     }
53565   }
53566
53567   jresult = (void *)result;
53568   return jresult;
53569 }
53570
53571
53572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53573   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53574   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53575
53576   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53577   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53578   {
53579     try {
53580       (arg1)->Remove(arg2);
53581     } catch (std::out_of_range& e) {
53582       {
53583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53584       };
53585     } catch (std::exception& e) {
53586       {
53587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53588       };
53589     } catch (Dali::DaliException e) {
53590       {
53591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53592       };
53593     } catch (...) {
53594       {
53595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53596       };
53597     }
53598   }
53599
53600 }
53601
53602
53603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53604   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53605   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53606
53607   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53608   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53609   if (!arg2) {
53610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53611     return ;
53612   }
53613   {
53614     try {
53615       (arg1)->Swap(*arg2);
53616     } catch (std::out_of_range& e) {
53617       {
53618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53619       };
53620     } catch (std::exception& e) {
53621       {
53622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53623       };
53624     } catch (Dali::DaliException e) {
53625       {
53626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53627       };
53628     } catch (...) {
53629       {
53630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53631       };
53632     }
53633   }
53634
53635 }
53636
53637
53638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53639   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53640
53641   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53642   {
53643     try {
53644       (arg1)->Clear();
53645     } catch (std::out_of_range& e) {
53646       {
53647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53648       };
53649     } catch (std::exception& e) {
53650       {
53651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53652       };
53653     } catch (Dali::DaliException e) {
53654       {
53655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53656       };
53657     } catch (...) {
53658       {
53659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53660       };
53661     }
53662   }
53663
53664 }
53665
53666
53667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53668   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53669
53670   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53671   {
53672     try {
53673       (arg1)->Release();
53674     } catch (std::out_of_range& e) {
53675       {
53676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53677       };
53678     } catch (std::exception& e) {
53679       {
53680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53681       };
53682     } catch (Dali::DaliException e) {
53683       {
53684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53685       };
53686     } catch (...) {
53687       {
53688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53689       };
53690     }
53691   }
53692
53693 }
53694
53695
53696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53697   void * jresult ;
53698   Dali::Signal< void () > *result = 0 ;
53699
53700   {
53701     try {
53702       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53703     } catch (std::out_of_range& e) {
53704       {
53705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53706       };
53707     } catch (std::exception& e) {
53708       {
53709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53710       };
53711     } catch (Dali::DaliException e) {
53712       {
53713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53714       };
53715     } catch (...) {
53716       {
53717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53718       };
53719     }
53720   }
53721
53722   jresult = (void *)result;
53723   return jresult;
53724 }
53725
53726
53727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53728   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53729
53730   arg1 = (Dali::Signal< void () > *)jarg1;
53731   {
53732     try {
53733       delete arg1;
53734     } catch (std::out_of_range& e) {
53735       {
53736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53737       };
53738     } catch (std::exception& e) {
53739       {
53740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53741       };
53742     } catch (Dali::DaliException e) {
53743       {
53744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53745       };
53746     } catch (...) {
53747       {
53748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53749       };
53750     }
53751   }
53752
53753 }
53754
53755
53756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53757   unsigned int jresult ;
53758   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53759   bool result;
53760
53761   arg1 = (Dali::Signal< void () > *)jarg1;
53762   {
53763     try {
53764       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53765     } catch (std::out_of_range& e) {
53766       {
53767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53768       };
53769     } catch (std::exception& e) {
53770       {
53771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53772       };
53773     } catch (Dali::DaliException e) {
53774       {
53775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53776       };
53777     } catch (...) {
53778       {
53779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53780       };
53781     }
53782   }
53783
53784   jresult = result;
53785   return jresult;
53786 }
53787
53788
53789 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53790   unsigned long jresult ;
53791   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53792   std::size_t result;
53793
53794   arg1 = (Dali::Signal< void () > *)jarg1;
53795   {
53796     try {
53797       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53798     } catch (std::out_of_range& e) {
53799       {
53800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53801       };
53802     } catch (std::exception& e) {
53803       {
53804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53805       };
53806     } catch (Dali::DaliException e) {
53807       {
53808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53809       };
53810     } catch (...) {
53811       {
53812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53813       };
53814     }
53815   }
53816
53817   jresult = (unsigned long)result;
53818   return jresult;
53819 }
53820
53821
53822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53823   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53824   void (*arg2)() = (void (*)()) 0 ;
53825
53826   arg1 = (Dali::Signal< void () > *)jarg1;
53827   arg2 = (void (*)())jarg2;
53828   {
53829     try {
53830       (arg1)->Connect(arg2);
53831     } catch (std::out_of_range& e) {
53832       {
53833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53834       };
53835     } catch (std::exception& e) {
53836       {
53837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53838       };
53839     } catch (Dali::DaliException e) {
53840       {
53841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53842       };
53843     } catch (...) {
53844       {
53845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53846       };
53847     }
53848   }
53849
53850 }
53851
53852
53853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53854   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53855   void (*arg2)() = (void (*)()) 0 ;
53856
53857   arg1 = (Dali::Signal< void () > *)jarg1;
53858   arg2 = (void (*)())jarg2;
53859   {
53860     try {
53861       (arg1)->Disconnect(arg2);
53862     } catch (std::out_of_range& e) {
53863       {
53864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53865       };
53866     } catch (std::exception& e) {
53867       {
53868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53869       };
53870     } catch (Dali::DaliException e) {
53871       {
53872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53873       };
53874     } catch (...) {
53875       {
53876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53877       };
53878     }
53879   }
53880
53881 }
53882
53883
53884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53885   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53886   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53887   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53888
53889   arg1 = (Dali::Signal< void () > *)jarg1;
53890   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53891   arg3 = (Dali::FunctorDelegate *)jarg3;
53892   {
53893     try {
53894       (arg1)->Connect(arg2,arg3);
53895     } catch (std::out_of_range& e) {
53896       {
53897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53898       };
53899     } catch (std::exception& e) {
53900       {
53901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53902       };
53903     } catch (Dali::DaliException e) {
53904       {
53905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53906       };
53907     } catch (...) {
53908       {
53909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53910       };
53911     }
53912   }
53913
53914 }
53915
53916
53917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53918   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53919
53920   arg1 = (Dali::Signal< void () > *)jarg1;
53921   {
53922     try {
53923       (arg1)->Emit();
53924     } catch (std::out_of_range& e) {
53925       {
53926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53927       };
53928     } catch (std::exception& e) {
53929       {
53930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53931       };
53932     } catch (Dali::DaliException e) {
53933       {
53934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53935       };
53936     } catch (...) {
53937       {
53938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53939       };
53940     }
53941   }
53942
53943 }
53944
53945
53946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53947   unsigned int jresult ;
53948   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53949   bool result;
53950
53951   arg1 = (Dali::Signal< void (float) > *)jarg1;
53952   {
53953     try {
53954       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53955     } catch (std::out_of_range& e) {
53956       {
53957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53958       };
53959     } catch (std::exception& e) {
53960       {
53961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53962       };
53963     } catch (Dali::DaliException e) {
53964       {
53965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53966       };
53967     } catch (...) {
53968       {
53969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53970       };
53971     }
53972   }
53973
53974   jresult = result;
53975   return jresult;
53976 }
53977
53978
53979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53980   unsigned long jresult ;
53981   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53982   std::size_t result;
53983
53984   arg1 = (Dali::Signal< void (float) > *)jarg1;
53985   {
53986     try {
53987       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53988     } catch (std::out_of_range& e) {
53989       {
53990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53991       };
53992     } catch (std::exception& e) {
53993       {
53994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53995       };
53996     } catch (Dali::DaliException e) {
53997       {
53998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53999       };
54000     } catch (...) {
54001       {
54002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54003       };
54004     }
54005   }
54006
54007   jresult = (unsigned long)result;
54008   return jresult;
54009 }
54010
54011
54012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
54013   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54014   void (*arg2)(float) = (void (*)(float)) 0 ;
54015
54016   arg1 = (Dali::Signal< void (float) > *)jarg1;
54017   arg2 = (void (*)(float))jarg2;
54018   {
54019     try {
54020       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
54021     } catch (std::out_of_range& e) {
54022       {
54023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54024       };
54025     } catch (std::exception& e) {
54026       {
54027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54028       };
54029     } catch (Dali::DaliException e) {
54030       {
54031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54032       };
54033     } catch (...) {
54034       {
54035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54036       };
54037     }
54038   }
54039
54040 }
54041
54042
54043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
54044   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54045   void (*arg2)(float) = (void (*)(float)) 0 ;
54046
54047   arg1 = (Dali::Signal< void (float) > *)jarg1;
54048   arg2 = (void (*)(float))jarg2;
54049   {
54050     try {
54051       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
54052     } catch (std::out_of_range& e) {
54053       {
54054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54055       };
54056     } catch (std::exception& e) {
54057       {
54058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54059       };
54060     } catch (Dali::DaliException e) {
54061       {
54062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54063       };
54064     } catch (...) {
54065       {
54066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54067       };
54068     }
54069   }
54070
54071 }
54072
54073
54074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
54075   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54076   float arg2 ;
54077
54078   arg1 = (Dali::Signal< void (float) > *)jarg1;
54079   arg2 = (float)jarg2;
54080   {
54081     try {
54082       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
54083     } catch (std::out_of_range& e) {
54084       {
54085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54086       };
54087     } catch (std::exception& e) {
54088       {
54089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54090       };
54091     } catch (Dali::DaliException e) {
54092       {
54093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54094       };
54095     } catch (...) {
54096       {
54097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54098       };
54099     }
54100   }
54101
54102 }
54103
54104
54105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54106   void * jresult ;
54107   Dali::Signal< void (float) > *result = 0 ;
54108
54109   {
54110     try {
54111       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54112     } catch (std::out_of_range& e) {
54113       {
54114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54115       };
54116     } catch (std::exception& e) {
54117       {
54118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54119       };
54120     } catch (Dali::DaliException e) {
54121       {
54122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54123       };
54124     } catch (...) {
54125       {
54126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54127       };
54128     }
54129   }
54130
54131   jresult = (void *)result;
54132   return jresult;
54133 }
54134
54135
54136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54137   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54138
54139   arg1 = (Dali::Signal< void (float) > *)jarg1;
54140   {
54141     try {
54142       delete arg1;
54143     } catch (std::out_of_range& e) {
54144       {
54145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54146       };
54147     } catch (std::exception& e) {
54148       {
54149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54150       };
54151     } catch (Dali::DaliException e) {
54152       {
54153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54154       };
54155     } catch (...) {
54156       {
54157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54158       };
54159     }
54160   }
54161
54162 }
54163
54164
54165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54166   unsigned int jresult ;
54167   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54168   bool result;
54169
54170   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54171   {
54172     try {
54173       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54174     } catch (std::out_of_range& e) {
54175       {
54176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54177       };
54178     } catch (std::exception& e) {
54179       {
54180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54181       };
54182     } catch (Dali::DaliException e) {
54183       {
54184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54185       };
54186     } catch (...) {
54187       {
54188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54189       };
54190     }
54191   }
54192
54193   jresult = result;
54194   return jresult;
54195 }
54196
54197
54198 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54199   unsigned long jresult ;
54200   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54201   std::size_t result;
54202
54203   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54204   {
54205     try {
54206       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54207     } catch (std::out_of_range& e) {
54208       {
54209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54210       };
54211     } catch (std::exception& e) {
54212       {
54213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54214       };
54215     } catch (Dali::DaliException e) {
54216       {
54217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54218       };
54219     } catch (...) {
54220       {
54221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54222       };
54223     }
54224   }
54225
54226   jresult = (unsigned long)result;
54227   return jresult;
54228 }
54229
54230
54231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54232   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54233   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54234
54235   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54236   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54237   {
54238     try {
54239       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54240     } catch (std::out_of_range& e) {
54241       {
54242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54243       };
54244     } catch (std::exception& e) {
54245       {
54246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54247       };
54248     } catch (Dali::DaliException e) {
54249       {
54250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54251       };
54252     } catch (...) {
54253       {
54254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54255       };
54256     }
54257   }
54258
54259 }
54260
54261
54262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54263   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54264   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54265
54266   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54267   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54268   {
54269     try {
54270       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54271     } catch (std::out_of_range& e) {
54272       {
54273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54274       };
54275     } catch (std::exception& e) {
54276       {
54277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54278       };
54279     } catch (Dali::DaliException e) {
54280       {
54281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54282       };
54283     } catch (...) {
54284       {
54285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54286       };
54287     }
54288   }
54289
54290 }
54291
54292
54293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54294   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54295   Dali::BaseHandle arg2 ;
54296   Dali::BaseHandle *argp2 ;
54297
54298   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54299   argp2 = (Dali::BaseHandle *)jarg2;
54300   if (!argp2) {
54301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54302     return ;
54303   }
54304   arg2 = *argp2;
54305   {
54306     try {
54307       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54308     } catch (std::out_of_range& e) {
54309       {
54310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54311       };
54312     } catch (std::exception& e) {
54313       {
54314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54315       };
54316     } catch (Dali::DaliException e) {
54317       {
54318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54319       };
54320     } catch (...) {
54321       {
54322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54323       };
54324     }
54325   }
54326
54327 }
54328
54329
54330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54331   void * jresult ;
54332   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54333
54334   {
54335     try {
54336       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54337     } catch (std::out_of_range& e) {
54338       {
54339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54340       };
54341     } catch (std::exception& e) {
54342       {
54343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54344       };
54345     } catch (Dali::DaliException e) {
54346       {
54347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54348       };
54349     } catch (...) {
54350       {
54351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54352       };
54353     }
54354   }
54355
54356   jresult = (void *)result;
54357   return jresult;
54358 }
54359
54360
54361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54362   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54363
54364   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54365   {
54366     try {
54367       delete arg1;
54368     } catch (std::out_of_range& e) {
54369       {
54370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54371       };
54372     } catch (std::exception& e) {
54373       {
54374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54375       };
54376     } catch (Dali::DaliException e) {
54377       {
54378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54379       };
54380     } catch (...) {
54381       {
54382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54383       };
54384     }
54385   }
54386
54387 }
54388
54389
54390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54391   unsigned int jresult ;
54392   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54393   bool result;
54394
54395   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54396   {
54397     try {
54398       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54399     } catch (std::out_of_range& e) {
54400       {
54401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54402       };
54403     } catch (std::exception& e) {
54404       {
54405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54406       };
54407     } catch (Dali::DaliException e) {
54408       {
54409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54410       };
54411     } catch (...) {
54412       {
54413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54414       };
54415     }
54416   }
54417
54418   jresult = result;
54419   return jresult;
54420 }
54421
54422
54423 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54424   unsigned long jresult ;
54425   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54426   std::size_t result;
54427
54428   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54429   {
54430     try {
54431       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54432     } catch (std::out_of_range& e) {
54433       {
54434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54435       };
54436     } catch (std::exception& e) {
54437       {
54438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54439       };
54440     } catch (Dali::DaliException e) {
54441       {
54442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54443       };
54444     } catch (...) {
54445       {
54446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54447       };
54448     }
54449   }
54450
54451   jresult = (unsigned long)result;
54452   return jresult;
54453 }
54454
54455
54456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54457   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54458   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54459
54460   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54461   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54462   {
54463     try {
54464       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54465     } catch (std::out_of_range& e) {
54466       {
54467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54468       };
54469     } catch (std::exception& e) {
54470       {
54471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54472       };
54473     } catch (Dali::DaliException e) {
54474       {
54475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54476       };
54477     } catch (...) {
54478       {
54479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54480       };
54481     }
54482   }
54483
54484 }
54485
54486
54487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54488   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54489   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54490
54491   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54492   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54493   {
54494     try {
54495       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54496     } catch (std::out_of_range& e) {
54497       {
54498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54499       };
54500     } catch (std::exception& e) {
54501       {
54502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54503       };
54504     } catch (Dali::DaliException e) {
54505       {
54506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54507       };
54508     } catch (...) {
54509       {
54510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54511       };
54512     }
54513   }
54514
54515 }
54516
54517
54518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54519   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54520   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54521
54522   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54523   arg2 = (Dali::RefObject *)jarg2;
54524   {
54525     try {
54526       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54527     } catch (std::out_of_range& e) {
54528       {
54529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54530       };
54531     } catch (std::exception& e) {
54532       {
54533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54534       };
54535     } catch (Dali::DaliException e) {
54536       {
54537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54538       };
54539     } catch (...) {
54540       {
54541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54542       };
54543     }
54544   }
54545
54546 }
54547
54548
54549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54550   void * jresult ;
54551   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54552
54553   {
54554     try {
54555       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54556     } catch (std::out_of_range& e) {
54557       {
54558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54559       };
54560     } catch (std::exception& e) {
54561       {
54562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54563       };
54564     } catch (Dali::DaliException e) {
54565       {
54566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54567       };
54568     } catch (...) {
54569       {
54570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54571       };
54572     }
54573   }
54574
54575   jresult = (void *)result;
54576   return jresult;
54577 }
54578
54579
54580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54581   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54582
54583   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54584   {
54585     try {
54586       delete arg1;
54587     } catch (std::out_of_range& e) {
54588       {
54589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54590       };
54591     } catch (std::exception& e) {
54592       {
54593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54594       };
54595     } catch (Dali::DaliException e) {
54596       {
54597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54598       };
54599     } catch (...) {
54600       {
54601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54602       };
54603     }
54604   }
54605
54606 }
54607
54608
54609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54610   unsigned int jresult ;
54611   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54612   bool result;
54613
54614   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54615   {
54616     try {
54617       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54618     } catch (std::out_of_range& e) {
54619       {
54620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54621       };
54622     } catch (std::exception& e) {
54623       {
54624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54625       };
54626     } catch (Dali::DaliException e) {
54627       {
54628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54629       };
54630     } catch (...) {
54631       {
54632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54633       };
54634     }
54635   }
54636
54637   jresult = result;
54638   return jresult;
54639 }
54640
54641
54642 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54643   unsigned long jresult ;
54644   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54645   std::size_t result;
54646
54647   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54648   {
54649     try {
54650       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54651     } catch (std::out_of_range& e) {
54652       {
54653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54654       };
54655     } catch (std::exception& e) {
54656       {
54657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54658       };
54659     } catch (Dali::DaliException e) {
54660       {
54661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54662       };
54663     } catch (...) {
54664       {
54665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54666       };
54667     }
54668   }
54669
54670   jresult = (unsigned long)result;
54671   return jresult;
54672 }
54673
54674
54675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54676   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54677   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54678
54679   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54680   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54681   {
54682     try {
54683       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54684     } catch (std::out_of_range& e) {
54685       {
54686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54687       };
54688     } catch (std::exception& e) {
54689       {
54690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54691       };
54692     } catch (Dali::DaliException e) {
54693       {
54694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54695       };
54696     } catch (...) {
54697       {
54698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54699       };
54700     }
54701   }
54702
54703 }
54704
54705
54706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54707   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54708   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54709
54710   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54711   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54712   {
54713     try {
54714       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54715     } catch (std::out_of_range& e) {
54716       {
54717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54718       };
54719     } catch (std::exception& e) {
54720       {
54721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54722       };
54723     } catch (Dali::DaliException e) {
54724       {
54725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54726       };
54727     } catch (...) {
54728       {
54729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54730       };
54731     }
54732   }
54733
54734 }
54735
54736
54737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54738   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54739   Dali::PropertyNotification *arg2 = 0 ;
54740
54741   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54742   arg2 = (Dali::PropertyNotification *)jarg2;
54743   if (!arg2) {
54744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54745     return ;
54746   }
54747   {
54748     try {
54749       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54750     } catch (std::out_of_range& e) {
54751       {
54752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54753       };
54754     } catch (std::exception& e) {
54755       {
54756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54757       };
54758     } catch (Dali::DaliException e) {
54759       {
54760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54761       };
54762     } catch (...) {
54763       {
54764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54765       };
54766     }
54767   }
54768
54769 }
54770
54771
54772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54773   void * jresult ;
54774   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54775
54776   {
54777     try {
54778       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54779     } catch (std::out_of_range& e) {
54780       {
54781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54782       };
54783     } catch (std::exception& e) {
54784       {
54785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54786       };
54787     } catch (Dali::DaliException e) {
54788       {
54789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54790       };
54791     } catch (...) {
54792       {
54793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54794       };
54795     }
54796   }
54797
54798   jresult = (void *)result;
54799   return jresult;
54800 }
54801
54802
54803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54804   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54805
54806   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54807   {
54808     try {
54809       delete arg1;
54810     } catch (std::out_of_range& e) {
54811       {
54812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54813       };
54814     } catch (std::exception& e) {
54815       {
54816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54817       };
54818     } catch (Dali::DaliException e) {
54819       {
54820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54821       };
54822     } catch (...) {
54823       {
54824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54825       };
54826     }
54827   }
54828
54829 }
54830
54831
54832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54833   unsigned int jresult ;
54834   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54835   bool result;
54836
54837   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54838   {
54839     try {
54840       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54841     } catch (std::out_of_range& e) {
54842       {
54843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54844       };
54845     } catch (std::exception& e) {
54846       {
54847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54848       };
54849     } catch (Dali::DaliException e) {
54850       {
54851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54852       };
54853     } catch (...) {
54854       {
54855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54856       };
54857     }
54858   }
54859
54860   jresult = result;
54861   return jresult;
54862 }
54863
54864
54865 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54866   unsigned long jresult ;
54867   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54868   std::size_t result;
54869
54870   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54871   {
54872     try {
54873       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54874     } catch (std::out_of_range& e) {
54875       {
54876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54877       };
54878     } catch (std::exception& e) {
54879       {
54880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54881       };
54882     } catch (Dali::DaliException e) {
54883       {
54884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54885       };
54886     } catch (...) {
54887       {
54888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54889       };
54890     }
54891   }
54892
54893   jresult = (unsigned long)result;
54894   return jresult;
54895 }
54896
54897
54898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54899   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54900   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54901
54902   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54903   arg2 = (void (*)(Dali::Image))jarg2;
54904   {
54905     try {
54906       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54907     } catch (std::out_of_range& e) {
54908       {
54909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54910       };
54911     } catch (std::exception& e) {
54912       {
54913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54914       };
54915     } catch (Dali::DaliException e) {
54916       {
54917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54918       };
54919     } catch (...) {
54920       {
54921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54922       };
54923     }
54924   }
54925
54926 }
54927
54928
54929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54930   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54931   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54932
54933   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54934   arg2 = (void (*)(Dali::Image))jarg2;
54935   {
54936     try {
54937       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54938     } catch (std::out_of_range& e) {
54939       {
54940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54941       };
54942     } catch (std::exception& e) {
54943       {
54944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54945       };
54946     } catch (Dali::DaliException e) {
54947       {
54948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54949       };
54950     } catch (...) {
54951       {
54952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54953       };
54954     }
54955   }
54956
54957 }
54958
54959
54960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54961   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54962   Dali::Image arg2 ;
54963   Dali::Image *argp2 ;
54964
54965   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54966   argp2 = (Dali::Image *)jarg2;
54967   if (!argp2) {
54968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54969     return ;
54970   }
54971   arg2 = *argp2;
54972   {
54973     try {
54974       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54975     } catch (std::out_of_range& e) {
54976       {
54977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54978       };
54979     } catch (std::exception& e) {
54980       {
54981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54982       };
54983     } catch (Dali::DaliException e) {
54984       {
54985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54986       };
54987     } catch (...) {
54988       {
54989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54990       };
54991     }
54992   }
54993
54994 }
54995
54996
54997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54998   void * jresult ;
54999   Dali::Signal< void (Dali::Image) > *result = 0 ;
55000
55001   {
55002     try {
55003       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
55004     } catch (std::out_of_range& e) {
55005       {
55006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55007       };
55008     } catch (std::exception& e) {
55009       {
55010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55011       };
55012     } catch (Dali::DaliException e) {
55013       {
55014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55015       };
55016     } catch (...) {
55017       {
55018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55019       };
55020     }
55021   }
55022
55023   jresult = (void *)result;
55024   return jresult;
55025 }
55026
55027
55028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
55029   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
55030
55031   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
55032   {
55033     try {
55034       delete arg1;
55035     } catch (std::out_of_range& e) {
55036       {
55037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55038       };
55039     } catch (std::exception& e) {
55040       {
55041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55042       };
55043     } catch (Dali::DaliException e) {
55044       {
55045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55046       };
55047     } catch (...) {
55048       {
55049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55050       };
55051     }
55052   }
55053
55054 }
55055
55056
55057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
55058   void * jresult ;
55059   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
55060
55061   {
55062     try {
55063       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
55064     } catch (std::out_of_range& e) {
55065       {
55066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55067       };
55068     } catch (std::exception& e) {
55069       {
55070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55071       };
55072     } catch (Dali::DaliException e) {
55073       {
55074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55075       };
55076     } catch (...) {
55077       {
55078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55079       };
55080     }
55081   }
55082
55083   jresult = (void *)result;
55084   return jresult;
55085 }
55086
55087
55088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55089   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55090
55091   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55092   {
55093     try {
55094       delete arg1;
55095     } catch (std::out_of_range& e) {
55096       {
55097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55098       };
55099     } catch (std::exception& e) {
55100       {
55101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55102       };
55103     } catch (Dali::DaliException e) {
55104       {
55105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55106       };
55107     } catch (...) {
55108       {
55109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55110       };
55111     }
55112   }
55113
55114 }
55115
55116
55117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55118   unsigned int jresult ;
55119   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55120   bool result;
55121
55122   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55123   {
55124     try {
55125       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);
55126     } catch (std::out_of_range& e) {
55127       {
55128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55129       };
55130     } catch (std::exception& e) {
55131       {
55132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55133       };
55134     } catch (Dali::DaliException e) {
55135       {
55136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55137       };
55138     } catch (...) {
55139       {
55140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55141       };
55142     }
55143   }
55144
55145   jresult = result;
55146   return jresult;
55147 }
55148
55149
55150 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55151   unsigned long jresult ;
55152   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55153   std::size_t result;
55154
55155   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55156   {
55157     try {
55158       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);
55159     } catch (std::out_of_range& e) {
55160       {
55161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55162       };
55163     } catch (std::exception& e) {
55164       {
55165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55166       };
55167     } catch (Dali::DaliException e) {
55168       {
55169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55170       };
55171     } catch (...) {
55172       {
55173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55174       };
55175     }
55176   }
55177
55178   jresult = (unsigned long)result;
55179   return jresult;
55180 }
55181
55182
55183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55184   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55185   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55186
55187   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55188   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55189   {
55190     try {
55191       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55192     } catch (std::out_of_range& e) {
55193       {
55194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55195       };
55196     } catch (std::exception& e) {
55197       {
55198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55199       };
55200     } catch (Dali::DaliException e) {
55201       {
55202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55203       };
55204     } catch (...) {
55205       {
55206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55207       };
55208     }
55209   }
55210
55211 }
55212
55213
55214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55215   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55216   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55217
55218   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55219   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55220   {
55221     try {
55222       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55223     } catch (std::out_of_range& e) {
55224       {
55225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55226       };
55227     } catch (std::exception& e) {
55228       {
55229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55230       };
55231     } catch (Dali::DaliException e) {
55232       {
55233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55234       };
55235     } catch (...) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55238       };
55239     }
55240   }
55241
55242 }
55243
55244
55245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55246   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55247   Dali::Actor arg2 ;
55248   Dali::LongPressGesture *arg3 = 0 ;
55249   Dali::Actor *argp2 ;
55250
55251   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55252   argp2 = (Dali::Actor *)jarg2;
55253   if (!argp2) {
55254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55255     return ;
55256   }
55257   arg2 = *argp2;
55258   arg3 = (Dali::LongPressGesture *)jarg3;
55259   if (!arg3) {
55260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55261     return ;
55262   }
55263   {
55264     try {
55265       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55266     } catch (std::out_of_range& e) {
55267       {
55268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55269       };
55270     } catch (std::exception& e) {
55271       {
55272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55273       };
55274     } catch (Dali::DaliException e) {
55275       {
55276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55277       };
55278     } catch (...) {
55279       {
55280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55281       };
55282     }
55283   }
55284
55285 }
55286
55287
55288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55289   void * jresult ;
55290   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55291
55292   {
55293     try {
55294       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55295     } catch (std::out_of_range& e) {
55296       {
55297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55298       };
55299     } catch (std::exception& e) {
55300       {
55301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55302       };
55303     } catch (Dali::DaliException e) {
55304       {
55305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55306       };
55307     } catch (...) {
55308       {
55309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55310       };
55311     }
55312   }
55313
55314   jresult = (void *)result;
55315   return jresult;
55316 }
55317
55318
55319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55320   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55321
55322   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55323   {
55324     try {
55325       delete arg1;
55326     } catch (std::out_of_range& e) {
55327       {
55328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55329       };
55330     } catch (std::exception& e) {
55331       {
55332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55333       };
55334     } catch (Dali::DaliException e) {
55335       {
55336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55337       };
55338     } catch (...) {
55339       {
55340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55341       };
55342     }
55343   }
55344
55345 }
55346
55347
55348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55349   unsigned int jresult ;
55350   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55351   bool result;
55352
55353   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55354   {
55355     try {
55356       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);
55357     } catch (std::out_of_range& e) {
55358       {
55359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55360       };
55361     } catch (std::exception& e) {
55362       {
55363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55364       };
55365     } catch (Dali::DaliException e) {
55366       {
55367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55368       };
55369     } catch (...) {
55370       {
55371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55372       };
55373     }
55374   }
55375
55376   jresult = result;
55377   return jresult;
55378 }
55379
55380
55381 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55382   unsigned long jresult ;
55383   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55384   std::size_t result;
55385
55386   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55387   {
55388     try {
55389       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);
55390     } catch (std::out_of_range& e) {
55391       {
55392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55393       };
55394     } catch (std::exception& e) {
55395       {
55396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55397       };
55398     } catch (Dali::DaliException e) {
55399       {
55400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55401       };
55402     } catch (...) {
55403       {
55404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55405       };
55406     }
55407   }
55408
55409   jresult = (unsigned long)result;
55410   return jresult;
55411 }
55412
55413
55414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55415   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55416   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55417
55418   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55419   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55420   {
55421     try {
55422       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55423     } catch (std::out_of_range& e) {
55424       {
55425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55426       };
55427     } catch (std::exception& e) {
55428       {
55429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55430       };
55431     } catch (Dali::DaliException e) {
55432       {
55433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55434       };
55435     } catch (...) {
55436       {
55437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55438       };
55439     }
55440   }
55441
55442 }
55443
55444
55445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55446   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55447   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55448
55449   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55450   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55451   {
55452     try {
55453       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55454     } catch (std::out_of_range& e) {
55455       {
55456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55457       };
55458     } catch (std::exception& e) {
55459       {
55460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55461       };
55462     } catch (Dali::DaliException e) {
55463       {
55464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55465       };
55466     } catch (...) {
55467       {
55468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55469       };
55470     }
55471   }
55472
55473 }
55474
55475
55476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55477   unsigned int jresult ;
55478   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55479   Dali::Actor arg2 ;
55480   Dali::TouchData *arg3 = 0 ;
55481   Dali::Actor *argp2 ;
55482   bool result;
55483
55484   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55485   argp2 = (Dali::Actor *)jarg2;
55486   if (!argp2) {
55487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55488     return 0;
55489   }
55490   arg2 = *argp2;
55491   arg3 = (Dali::TouchData *)jarg3;
55492   if (!arg3) {
55493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55494     return 0;
55495   }
55496   {
55497     try {
55498       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55499     } catch (std::out_of_range& e) {
55500       {
55501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55502       };
55503     } catch (std::exception& e) {
55504       {
55505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55506       };
55507     } catch (Dali::DaliException e) {
55508       {
55509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55510       };
55511     } catch (...) {
55512       {
55513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55514       };
55515     }
55516   }
55517
55518   jresult = result;
55519   return jresult;
55520 }
55521
55522
55523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55524   void * jresult ;
55525   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55526
55527   {
55528     try {
55529       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55530     } catch (std::out_of_range& e) {
55531       {
55532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55533       };
55534     } catch (std::exception& e) {
55535       {
55536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55537       };
55538     } catch (Dali::DaliException e) {
55539       {
55540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55541       };
55542     } catch (...) {
55543       {
55544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55545       };
55546     }
55547   }
55548
55549   jresult = (void *)result;
55550   return jresult;
55551 }
55552
55553
55554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55555   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55556
55557   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55558   {
55559     try {
55560       delete arg1;
55561     } catch (std::out_of_range& e) {
55562       {
55563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55564       };
55565     } catch (std::exception& e) {
55566       {
55567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55568       };
55569     } catch (Dali::DaliException e) {
55570       {
55571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55572       };
55573     } catch (...) {
55574       {
55575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55576       };
55577     }
55578   }
55579
55580 }
55581
55582
55583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55584   unsigned int jresult ;
55585   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55586   bool result;
55587
55588   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55589   {
55590     try {
55591       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);
55592     } catch (std::out_of_range& e) {
55593       {
55594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55595       };
55596     } catch (std::exception& e) {
55597       {
55598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55599       };
55600     } catch (Dali::DaliException e) {
55601       {
55602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55603       };
55604     } catch (...) {
55605       {
55606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55607       };
55608     }
55609   }
55610
55611   jresult = result;
55612   return jresult;
55613 }
55614
55615
55616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55617   unsigned long jresult ;
55618   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55619   std::size_t result;
55620
55621   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55622   {
55623     try {
55624       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);
55625     } catch (std::out_of_range& e) {
55626       {
55627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55628       };
55629     } catch (std::exception& e) {
55630       {
55631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55632       };
55633     } catch (Dali::DaliException e) {
55634       {
55635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55636       };
55637     } catch (...) {
55638       {
55639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55640       };
55641     }
55642   }
55643
55644   jresult = (unsigned long)result;
55645   return jresult;
55646 }
55647
55648
55649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55650   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55651   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55652
55653   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55654   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55655   {
55656     try {
55657       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55658     } catch (std::out_of_range& e) {
55659       {
55660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55661       };
55662     } catch (std::exception& e) {
55663       {
55664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55665       };
55666     } catch (Dali::DaliException e) {
55667       {
55668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55669       };
55670     } catch (...) {
55671       {
55672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55673       };
55674     }
55675   }
55676
55677 }
55678
55679
55680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55681   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55682   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55683
55684   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55685   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55686   {
55687     try {
55688       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55689     } catch (std::out_of_range& e) {
55690       {
55691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55692       };
55693     } catch (std::exception& e) {
55694       {
55695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55696       };
55697     } catch (Dali::DaliException e) {
55698       {
55699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55700       };
55701     } catch (...) {
55702       {
55703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55704       };
55705     }
55706   }
55707
55708 }
55709
55710
55711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55712   unsigned int jresult ;
55713   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55714   Dali::Actor arg2 ;
55715   Dali::HoverEvent *arg3 = 0 ;
55716   Dali::Actor *argp2 ;
55717   bool result;
55718
55719   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55720   argp2 = (Dali::Actor *)jarg2;
55721   if (!argp2) {
55722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55723     return 0;
55724   }
55725   arg2 = *argp2;
55726   arg3 = (Dali::HoverEvent *)jarg3;
55727   if (!arg3) {
55728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55729     return 0;
55730   }
55731   {
55732     try {
55733       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55734     } catch (std::out_of_range& e) {
55735       {
55736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55737       };
55738     } catch (std::exception& e) {
55739       {
55740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55741       };
55742     } catch (Dali::DaliException e) {
55743       {
55744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55745       };
55746     } catch (...) {
55747       {
55748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55749       };
55750     }
55751   }
55752
55753   jresult = result;
55754   return jresult;
55755 }
55756
55757
55758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55759   void * jresult ;
55760   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55761
55762   {
55763     try {
55764       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55765     } catch (std::out_of_range& e) {
55766       {
55767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55768       };
55769     } catch (std::exception& e) {
55770       {
55771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55772       };
55773     } catch (Dali::DaliException e) {
55774       {
55775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55776       };
55777     } catch (...) {
55778       {
55779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55780       };
55781     }
55782   }
55783
55784   jresult = (void *)result;
55785   return jresult;
55786 }
55787
55788
55789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55790   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55791
55792   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55793   {
55794     try {
55795       delete arg1;
55796     } catch (std::out_of_range& e) {
55797       {
55798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55799       };
55800     } catch (std::exception& e) {
55801       {
55802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55803       };
55804     } catch (Dali::DaliException e) {
55805       {
55806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55807       };
55808     } catch (...) {
55809       {
55810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55811       };
55812     }
55813   }
55814
55815 }
55816
55817
55818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55819   unsigned int jresult ;
55820   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55821   bool result;
55822
55823   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55824   {
55825     try {
55826       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);
55827     } catch (std::out_of_range& e) {
55828       {
55829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55830       };
55831     } catch (std::exception& e) {
55832       {
55833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55834       };
55835     } catch (Dali::DaliException e) {
55836       {
55837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55838       };
55839     } catch (...) {
55840       {
55841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55842       };
55843     }
55844   }
55845
55846   jresult = result;
55847   return jresult;
55848 }
55849
55850
55851 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55852   unsigned long jresult ;
55853   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55854   std::size_t result;
55855
55856   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55857   {
55858     try {
55859       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);
55860     } catch (std::out_of_range& e) {
55861       {
55862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55863       };
55864     } catch (std::exception& e) {
55865       {
55866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55867       };
55868     } catch (Dali::DaliException e) {
55869       {
55870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55871       };
55872     } catch (...) {
55873       {
55874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55875       };
55876     }
55877   }
55878
55879   jresult = (unsigned long)result;
55880   return jresult;
55881 }
55882
55883
55884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55885   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55886   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55887
55888   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55889   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55890   {
55891     try {
55892       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55893     } catch (std::out_of_range& e) {
55894       {
55895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55896       };
55897     } catch (std::exception& e) {
55898       {
55899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55900       };
55901     } catch (Dali::DaliException e) {
55902       {
55903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55904       };
55905     } catch (...) {
55906       {
55907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55908       };
55909     }
55910   }
55911
55912 }
55913
55914
55915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55916   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55917   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55918
55919   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55920   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55921   {
55922     try {
55923       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55924     } catch (std::out_of_range& e) {
55925       {
55926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55927       };
55928     } catch (std::exception& e) {
55929       {
55930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55931       };
55932     } catch (Dali::DaliException e) {
55933       {
55934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55935       };
55936     } catch (...) {
55937       {
55938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55939       };
55940     }
55941   }
55942
55943 }
55944
55945
55946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55947   unsigned int jresult ;
55948   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55949   Dali::Actor arg2 ;
55950   Dali::WheelEvent *arg3 = 0 ;
55951   Dali::Actor *argp2 ;
55952   bool result;
55953
55954   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55955   argp2 = (Dali::Actor *)jarg2;
55956   if (!argp2) {
55957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55958     return 0;
55959   }
55960   arg2 = *argp2;
55961   arg3 = (Dali::WheelEvent *)jarg3;
55962   if (!arg3) {
55963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55964     return 0;
55965   }
55966   {
55967     try {
55968       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55969     } catch (std::out_of_range& e) {
55970       {
55971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55972       };
55973     } catch (std::exception& e) {
55974       {
55975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55976       };
55977     } catch (Dali::DaliException e) {
55978       {
55979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55980       };
55981     } catch (...) {
55982       {
55983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55984       };
55985     }
55986   }
55987
55988   jresult = result;
55989   return jresult;
55990 }
55991
55992
55993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55994   void * jresult ;
55995   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55996
55997   {
55998     try {
55999       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
56000     } catch (std::out_of_range& e) {
56001       {
56002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56003       };
56004     } catch (std::exception& e) {
56005       {
56006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56007       };
56008     } catch (Dali::DaliException e) {
56009       {
56010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56011       };
56012     } catch (...) {
56013       {
56014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56015       };
56016     }
56017   }
56018
56019   jresult = (void *)result;
56020   return jresult;
56021 }
56022
56023
56024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
56025   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
56026
56027   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
56028   {
56029     try {
56030       delete arg1;
56031     } catch (std::out_of_range& e) {
56032       {
56033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56034       };
56035     } catch (std::exception& e) {
56036       {
56037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56038       };
56039     } catch (Dali::DaliException e) {
56040       {
56041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56042       };
56043     } catch (...) {
56044       {
56045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56046       };
56047     }
56048   }
56049
56050 }
56051
56052
56053 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
56054   unsigned int jresult ;
56055   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56056   bool result;
56057
56058   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56059   {
56060     try {
56061       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
56062     } catch (std::out_of_range& e) {
56063       {
56064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56065       };
56066     } catch (std::exception& e) {
56067       {
56068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56069       };
56070     } catch (Dali::DaliException e) {
56071       {
56072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56073       };
56074     } catch (...) {
56075       {
56076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56077       };
56078     }
56079   }
56080
56081   jresult = result;
56082   return jresult;
56083 }
56084
56085
56086 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56087   unsigned long jresult ;
56088   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56089   std::size_t result;
56090
56091   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56092   {
56093     try {
56094       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56095     } catch (std::out_of_range& e) {
56096       {
56097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56098       };
56099     } catch (std::exception& e) {
56100       {
56101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56102       };
56103     } catch (Dali::DaliException e) {
56104       {
56105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56106       };
56107     } catch (...) {
56108       {
56109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56110       };
56111     }
56112   }
56113
56114   jresult = (unsigned long)result;
56115   return jresult;
56116 }
56117
56118
56119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56120   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56121   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56122
56123   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56124   arg2 = (void (*)(Dali::Actor))jarg2;
56125   {
56126     try {
56127       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56128     } catch (std::out_of_range& e) {
56129       {
56130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56131       };
56132     } catch (std::exception& e) {
56133       {
56134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56135       };
56136     } catch (Dali::DaliException e) {
56137       {
56138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56139       };
56140     } catch (...) {
56141       {
56142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56143       };
56144     }
56145   }
56146
56147 }
56148
56149
56150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56151   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56152   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56153
56154   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56155   arg2 = (void (*)(Dali::Actor))jarg2;
56156   {
56157     try {
56158       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56159     } catch (std::out_of_range& e) {
56160       {
56161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56162       };
56163     } catch (std::exception& e) {
56164       {
56165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56166       };
56167     } catch (Dali::DaliException e) {
56168       {
56169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56170       };
56171     } catch (...) {
56172       {
56173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56174       };
56175     }
56176   }
56177
56178 }
56179
56180
56181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56182   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56183   Dali::Actor arg2 ;
56184   Dali::Actor *argp2 ;
56185
56186   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56187   argp2 = (Dali::Actor *)jarg2;
56188   if (!argp2) {
56189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56190     return ;
56191   }
56192   arg2 = *argp2;
56193   {
56194     try {
56195       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56196     } catch (std::out_of_range& e) {
56197       {
56198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56199       };
56200     } catch (std::exception& e) {
56201       {
56202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56203       };
56204     } catch (Dali::DaliException e) {
56205       {
56206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56207       };
56208     } catch (...) {
56209       {
56210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56211       };
56212     }
56213   }
56214
56215 }
56216
56217
56218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56219   void * jresult ;
56220   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56221
56222   {
56223     try {
56224       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56225     } catch (std::out_of_range& e) {
56226       {
56227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56228       };
56229     } catch (std::exception& e) {
56230       {
56231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56232       };
56233     } catch (Dali::DaliException e) {
56234       {
56235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56236       };
56237     } catch (...) {
56238       {
56239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56240       };
56241     }
56242   }
56243
56244   jresult = (void *)result;
56245   return jresult;
56246 }
56247
56248
56249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56250   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56251
56252   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56253   {
56254     try {
56255       delete arg1;
56256     } catch (std::out_of_range& e) {
56257       {
56258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56259       };
56260     } catch (std::exception& e) {
56261       {
56262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56263       };
56264     } catch (Dali::DaliException e) {
56265       {
56266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56267       };
56268     } catch (...) {
56269       {
56270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56271       };
56272     }
56273   }
56274
56275 }
56276
56277
56278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56279   unsigned int jresult ;
56280   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56281   bool result;
56282
56283   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56284   {
56285     try {
56286       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56287     } catch (std::out_of_range& e) {
56288       {
56289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56290       };
56291     } catch (std::exception& e) {
56292       {
56293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56294       };
56295     } catch (Dali::DaliException e) {
56296       {
56297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56298       };
56299     } catch (...) {
56300       {
56301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56302       };
56303     }
56304   }
56305
56306   jresult = result;
56307   return jresult;
56308 }
56309
56310
56311 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56312   unsigned long jresult ;
56313   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56314   std::size_t result;
56315
56316   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56317   {
56318     try {
56319       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56320     } catch (std::out_of_range& e) {
56321       {
56322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56323       };
56324     } catch (std::exception& e) {
56325       {
56326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56327       };
56328     } catch (Dali::DaliException e) {
56329       {
56330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56331       };
56332     } catch (...) {
56333       {
56334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56335       };
56336     }
56337   }
56338
56339   jresult = (unsigned long)result;
56340   return jresult;
56341 }
56342
56343
56344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56345   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56346   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56347
56348   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56349   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56350   {
56351     try {
56352       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56353     } catch (std::out_of_range& e) {
56354       {
56355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56356       };
56357     } catch (std::exception& e) {
56358       {
56359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56360       };
56361     } catch (Dali::DaliException e) {
56362       {
56363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56364       };
56365     } catch (...) {
56366       {
56367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56368       };
56369     }
56370   }
56371
56372 }
56373
56374
56375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56376   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56377   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56378
56379   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56380   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56381   {
56382     try {
56383       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56384     } catch (std::out_of_range& e) {
56385       {
56386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56387       };
56388     } catch (std::exception& e) {
56389       {
56390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56391       };
56392     } catch (Dali::DaliException e) {
56393       {
56394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56395       };
56396     } catch (...) {
56397       {
56398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56399       };
56400     }
56401   }
56402
56403 }
56404
56405
56406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56407   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56408   Dali::KeyEvent *arg2 = 0 ;
56409
56410   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56411   arg2 = (Dali::KeyEvent *)jarg2;
56412   if (!arg2) {
56413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56414     return ;
56415   }
56416   {
56417     try {
56418       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56419     } catch (std::out_of_range& e) {
56420       {
56421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56422       };
56423     } catch (std::exception& e) {
56424       {
56425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56426       };
56427     } catch (Dali::DaliException e) {
56428       {
56429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56430       };
56431     } catch (...) {
56432       {
56433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56434       };
56435     }
56436   }
56437
56438 }
56439
56440
56441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56442   void * jresult ;
56443   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56444
56445   {
56446     try {
56447       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56448     } catch (std::out_of_range& e) {
56449       {
56450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56451       };
56452     } catch (std::exception& e) {
56453       {
56454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56455       };
56456     } catch (Dali::DaliException e) {
56457       {
56458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56459       };
56460     } catch (...) {
56461       {
56462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56463       };
56464     }
56465   }
56466
56467   jresult = (void *)result;
56468   return jresult;
56469 }
56470
56471
56472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56473   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56474
56475   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56476   {
56477     try {
56478       delete arg1;
56479     } catch (std::out_of_range& e) {
56480       {
56481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56482       };
56483     } catch (std::exception& e) {
56484       {
56485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56486       };
56487     } catch (Dali::DaliException e) {
56488       {
56489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56490       };
56491     } catch (...) {
56492       {
56493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56494       };
56495     }
56496   }
56497
56498 }
56499
56500
56501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56502   unsigned int jresult ;
56503   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56504   bool result;
56505
56506   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56507   {
56508     try {
56509       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56510     } catch (std::out_of_range& e) {
56511       {
56512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56513       };
56514     } catch (std::exception& e) {
56515       {
56516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56517       };
56518     } catch (Dali::DaliException e) {
56519       {
56520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56521       };
56522     } catch (...) {
56523       {
56524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56525       };
56526     }
56527   }
56528
56529   jresult = result;
56530   return jresult;
56531 }
56532
56533
56534 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56535   unsigned long jresult ;
56536   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56537   std::size_t result;
56538
56539   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56540   {
56541     try {
56542       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56543     } catch (std::out_of_range& e) {
56544       {
56545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56546       };
56547     } catch (std::exception& e) {
56548       {
56549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56550       };
56551     } catch (Dali::DaliException e) {
56552       {
56553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56554       };
56555     } catch (...) {
56556       {
56557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56558       };
56559     }
56560   }
56561
56562   jresult = (unsigned long)result;
56563   return jresult;
56564 }
56565
56566
56567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56568   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56569   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56570
56571   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56572   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56573   {
56574     try {
56575       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56576     } catch (std::out_of_range& e) {
56577       {
56578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56579       };
56580     } catch (std::exception& e) {
56581       {
56582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56583       };
56584     } catch (Dali::DaliException e) {
56585       {
56586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56587       };
56588     } catch (...) {
56589       {
56590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56591       };
56592     }
56593   }
56594
56595 }
56596
56597
56598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56599   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56600   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56601
56602   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56603   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56604   {
56605     try {
56606       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56607     } catch (std::out_of_range& e) {
56608       {
56609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56610       };
56611     } catch (std::exception& e) {
56612       {
56613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56614       };
56615     } catch (Dali::DaliException e) {
56616       {
56617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56618       };
56619     } catch (...) {
56620       {
56621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56622       };
56623     }
56624   }
56625
56626 }
56627
56628
56629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56630   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56631   Dali::TouchData *arg2 = 0 ;
56632
56633   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56634   arg2 = (Dali::TouchData *)jarg2;
56635   if (!arg2) {
56636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56637     return ;
56638   }
56639   {
56640     try {
56641       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56642     } catch (std::out_of_range& e) {
56643       {
56644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56645       };
56646     } catch (std::exception& e) {
56647       {
56648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56649       };
56650     } catch (Dali::DaliException e) {
56651       {
56652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56653       };
56654     } catch (...) {
56655       {
56656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56657       };
56658     }
56659   }
56660
56661 }
56662
56663
56664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56665   void * jresult ;
56666   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56667
56668   {
56669     try {
56670       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56671     } catch (std::out_of_range& e) {
56672       {
56673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56674       };
56675     } catch (std::exception& e) {
56676       {
56677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56678       };
56679     } catch (Dali::DaliException e) {
56680       {
56681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56682       };
56683     } catch (...) {
56684       {
56685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56686       };
56687     }
56688   }
56689
56690   jresult = (void *)result;
56691   return jresult;
56692 }
56693
56694
56695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56696   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56697
56698   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56699   {
56700     try {
56701       delete arg1;
56702     } catch (std::out_of_range& e) {
56703       {
56704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56705       };
56706     } catch (std::exception& e) {
56707       {
56708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56709       };
56710     } catch (Dali::DaliException e) {
56711       {
56712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56713       };
56714     } catch (...) {
56715       {
56716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56717       };
56718     }
56719   }
56720
56721 }
56722
56723
56724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56725   unsigned int jresult ;
56726   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56727   bool result;
56728
56729   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56730   {
56731     try {
56732       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56733     } catch (std::out_of_range& e) {
56734       {
56735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56736       };
56737     } catch (std::exception& e) {
56738       {
56739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56740       };
56741     } catch (Dali::DaliException e) {
56742       {
56743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56744       };
56745     } catch (...) {
56746       {
56747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56748       };
56749     }
56750   }
56751
56752   jresult = result;
56753   return jresult;
56754 }
56755
56756
56757 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56758   unsigned long jresult ;
56759   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56760   std::size_t result;
56761
56762   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56763   {
56764     try {
56765       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56766     } catch (std::out_of_range& e) {
56767       {
56768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56769       };
56770     } catch (std::exception& e) {
56771       {
56772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56773       };
56774     } catch (Dali::DaliException e) {
56775       {
56776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56777       };
56778     } catch (...) {
56779       {
56780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56781       };
56782     }
56783   }
56784
56785   jresult = (unsigned long)result;
56786   return jresult;
56787 }
56788
56789
56790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56791   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56792   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56793
56794   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56795   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56796   {
56797     try {
56798       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56799     } catch (std::out_of_range& e) {
56800       {
56801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56802       };
56803     } catch (std::exception& e) {
56804       {
56805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56806       };
56807     } catch (Dali::DaliException e) {
56808       {
56809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56810       };
56811     } catch (...) {
56812       {
56813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56814       };
56815     }
56816   }
56817
56818 }
56819
56820
56821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56822   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56823   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56824
56825   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56826   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56827   {
56828     try {
56829       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56830     } catch (std::out_of_range& e) {
56831       {
56832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56833       };
56834     } catch (std::exception& e) {
56835       {
56836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56837       };
56838     } catch (Dali::DaliException e) {
56839       {
56840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56841       };
56842     } catch (...) {
56843       {
56844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56845       };
56846     }
56847   }
56848
56849 }
56850
56851
56852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56853   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56854   Dali::WheelEvent *arg2 = 0 ;
56855
56856   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56857   arg2 = (Dali::WheelEvent *)jarg2;
56858   if (!arg2) {
56859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56860     return ;
56861   }
56862   {
56863     try {
56864       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56865     } catch (std::out_of_range& e) {
56866       {
56867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56868       };
56869     } catch (std::exception& e) {
56870       {
56871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56872       };
56873     } catch (Dali::DaliException e) {
56874       {
56875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56876       };
56877     } catch (...) {
56878       {
56879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56880       };
56881     }
56882   }
56883
56884 }
56885
56886
56887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56888   void * jresult ;
56889   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56890
56891   {
56892     try {
56893       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56894     } catch (std::out_of_range& e) {
56895       {
56896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56897       };
56898     } catch (std::exception& e) {
56899       {
56900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56901       };
56902     } catch (Dali::DaliException e) {
56903       {
56904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56905       };
56906     } catch (...) {
56907       {
56908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56909       };
56910     }
56911   }
56912
56913   jresult = (void *)result;
56914   return jresult;
56915 }
56916
56917
56918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56919   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56920
56921   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56922   {
56923     try {
56924       delete arg1;
56925     } catch (std::out_of_range& e) {
56926       {
56927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56928       };
56929     } catch (std::exception& e) {
56930       {
56931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56932       };
56933     } catch (Dali::DaliException e) {
56934       {
56935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56936       };
56937     } catch (...) {
56938       {
56939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56940       };
56941     }
56942   }
56943
56944 }
56945
56946
56947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56948   void * jresult ;
56949   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56950
56951   {
56952     try {
56953       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56954     } catch (std::out_of_range& e) {
56955       {
56956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56957       };
56958     } catch (std::exception& e) {
56959       {
56960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56961       };
56962     } catch (Dali::DaliException e) {
56963       {
56964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56965       };
56966     } catch (...) {
56967       {
56968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56969       };
56970     }
56971   }
56972
56973   jresult = (void *)result;
56974   return jresult;
56975 }
56976
56977
56978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56979   void * jresult ;
56980   Dali::Radian arg1 ;
56981   Dali::Radian arg2 ;
56982   Dali::Radian *argp1 ;
56983   Dali::Radian *argp2 ;
56984   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56985
56986   argp1 = (Dali::Radian *)jarg1;
56987   if (!argp1) {
56988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56989     return 0;
56990   }
56991   arg1 = *argp1;
56992   argp2 = (Dali::Radian *)jarg2;
56993   if (!argp2) {
56994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56995     return 0;
56996   }
56997   arg2 = *argp2;
56998   {
56999     try {
57000       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
57001     } catch (std::out_of_range& e) {
57002       {
57003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57004       };
57005     } catch (std::exception& e) {
57006       {
57007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57008       };
57009     } catch (Dali::DaliException e) {
57010       {
57011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57012       };
57013     } catch (...) {
57014       {
57015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57016       };
57017     }
57018   }
57019
57020   jresult = (void *)result;
57021   return jresult;
57022 }
57023
57024
57025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
57026   void * jresult ;
57027   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
57028   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
57029
57030   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57031   if (!arg1) {
57032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
57033     return 0;
57034   }
57035   {
57036     try {
57037       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
57038     } catch (std::out_of_range& e) {
57039       {
57040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57041       };
57042     } catch (std::exception& e) {
57043       {
57044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57045       };
57046     } catch (Dali::DaliException e) {
57047       {
57048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57049       };
57050     } catch (...) {
57051       {
57052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57053       };
57054     }
57055   }
57056
57057   jresult = (void *)result;
57058   return jresult;
57059 }
57060
57061
57062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
57063   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57064   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57065
57066   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57067   arg2 = (Dali::Radian *)jarg2;
57068   if (arg1) (arg1)->first = *arg2;
57069 }
57070
57071
57072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
57073   void * jresult ;
57074   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57075   Dali::Radian *result = 0 ;
57076
57077   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57078   result = (Dali::Radian *)& ((arg1)->first);
57079   jresult = (void *)result;
57080   return jresult;
57081 }
57082
57083
57084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
57085   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57086   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57087
57088   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57089   arg2 = (Dali::Radian *)jarg2;
57090   if (arg1) (arg1)->second = *arg2;
57091 }
57092
57093
57094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57095   void * jresult ;
57096   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57097   Dali::Radian *result = 0 ;
57098
57099   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57100   result = (Dali::Radian *)& ((arg1)->second);
57101   jresult = (void *)result;
57102   return jresult;
57103 }
57104
57105
57106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57107   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57108
57109   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57110   {
57111     try {
57112       delete arg1;
57113     } catch (std::out_of_range& e) {
57114       {
57115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57116       };
57117     } catch (std::exception& e) {
57118       {
57119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57120       };
57121     } catch (Dali::DaliException e) {
57122       {
57123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57124       };
57125     } catch (...) {
57126       {
57127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57128       };
57129     }
57130   }
57131
57132 }
57133
57134
57135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57136   unsigned int jresult ;
57137   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57138   bool result;
57139
57140   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57141   {
57142     try {
57143       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);
57144     } catch (std::out_of_range& e) {
57145       {
57146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57147       };
57148     } catch (std::exception& e) {
57149       {
57150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57151       };
57152     } catch (Dali::DaliException e) {
57153       {
57154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57155       };
57156     } catch (...) {
57157       {
57158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57159       };
57160     }
57161   }
57162
57163   jresult = result;
57164   return jresult;
57165 }
57166
57167
57168 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57169   unsigned long jresult ;
57170   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57171   std::size_t result;
57172
57173   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57174   {
57175     try {
57176       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);
57177     } catch (std::out_of_range& e) {
57178       {
57179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57180       };
57181     } catch (std::exception& e) {
57182       {
57183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57184       };
57185     } catch (Dali::DaliException e) {
57186       {
57187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57188       };
57189     } catch (...) {
57190       {
57191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57192       };
57193     }
57194   }
57195
57196   jresult = (unsigned long)result;
57197   return jresult;
57198 }
57199
57200
57201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57202   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57203   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57204
57205   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57206   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57207   {
57208     try {
57209       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57210     } catch (std::out_of_range& e) {
57211       {
57212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57213       };
57214     } catch (std::exception& e) {
57215       {
57216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57217       };
57218     } catch (Dali::DaliException e) {
57219       {
57220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57221       };
57222     } catch (...) {
57223       {
57224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57225       };
57226     }
57227   }
57228
57229 }
57230
57231
57232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57233   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57234   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57235
57236   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57237   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57238   {
57239     try {
57240       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57241     } catch (std::out_of_range& e) {
57242       {
57243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57244       };
57245     } catch (std::exception& e) {
57246       {
57247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57248       };
57249     } catch (Dali::DaliException e) {
57250       {
57251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57252       };
57253     } catch (...) {
57254       {
57255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57256       };
57257     }
57258   }
57259
57260 }
57261
57262
57263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57264   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57265   Dali::Actor arg2 ;
57266   Dali::PanGesture *arg3 = 0 ;
57267   Dali::Actor *argp2 ;
57268
57269   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57270   argp2 = (Dali::Actor *)jarg2;
57271   if (!argp2) {
57272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57273     return ;
57274   }
57275   arg2 = *argp2;
57276   arg3 = (Dali::PanGesture *)jarg3;
57277   if (!arg3) {
57278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57279     return ;
57280   }
57281   {
57282     try {
57283       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57284     } catch (std::out_of_range& e) {
57285       {
57286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57287       };
57288     } catch (std::exception& e) {
57289       {
57290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57291       };
57292     } catch (Dali::DaliException e) {
57293       {
57294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57295       };
57296     } catch (...) {
57297       {
57298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57299       };
57300     }
57301   }
57302
57303 }
57304
57305
57306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57307   void * jresult ;
57308   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57309
57310   {
57311     try {
57312       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57313     } catch (std::out_of_range& e) {
57314       {
57315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57316       };
57317     } catch (std::exception& e) {
57318       {
57319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57320       };
57321     } catch (Dali::DaliException e) {
57322       {
57323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57324       };
57325     } catch (...) {
57326       {
57327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57328       };
57329     }
57330   }
57331
57332   jresult = (void *)result;
57333   return jresult;
57334 }
57335
57336
57337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57338   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57339
57340   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57341   {
57342     try {
57343       delete arg1;
57344     } catch (std::out_of_range& e) {
57345       {
57346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57347       };
57348     } catch (std::exception& e) {
57349       {
57350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57351       };
57352     } catch (Dali::DaliException e) {
57353       {
57354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57355       };
57356     } catch (...) {
57357       {
57358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57359       };
57360     }
57361   }
57362
57363 }
57364
57365
57366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57367   unsigned int jresult ;
57368   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57369   bool result;
57370
57371   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57372   {
57373     try {
57374       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);
57375     } catch (std::out_of_range& e) {
57376       {
57377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57378       };
57379     } catch (std::exception& e) {
57380       {
57381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57382       };
57383     } catch (Dali::DaliException e) {
57384       {
57385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57386       };
57387     } catch (...) {
57388       {
57389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57390       };
57391     }
57392   }
57393
57394   jresult = result;
57395   return jresult;
57396 }
57397
57398
57399 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57400   unsigned long jresult ;
57401   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57402   std::size_t result;
57403
57404   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57405   {
57406     try {
57407       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);
57408     } catch (std::out_of_range& e) {
57409       {
57410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57411       };
57412     } catch (std::exception& e) {
57413       {
57414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57415       };
57416     } catch (Dali::DaliException e) {
57417       {
57418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57419       };
57420     } catch (...) {
57421       {
57422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57423       };
57424     }
57425   }
57426
57427   jresult = (unsigned long)result;
57428   return jresult;
57429 }
57430
57431
57432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57433   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57434   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57435
57436   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57437   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57438   {
57439     try {
57440       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57441     } catch (std::out_of_range& e) {
57442       {
57443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57444       };
57445     } catch (std::exception& e) {
57446       {
57447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57448       };
57449     } catch (Dali::DaliException e) {
57450       {
57451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57452       };
57453     } catch (...) {
57454       {
57455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57456       };
57457     }
57458   }
57459
57460 }
57461
57462
57463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57464   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57465   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57466
57467   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57468   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57469   {
57470     try {
57471       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57472     } catch (std::out_of_range& e) {
57473       {
57474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57475       };
57476     } catch (std::exception& e) {
57477       {
57478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57479       };
57480     } catch (Dali::DaliException e) {
57481       {
57482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57483       };
57484     } catch (...) {
57485       {
57486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57487       };
57488     }
57489   }
57490
57491 }
57492
57493
57494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57495   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57496   Dali::Actor arg2 ;
57497   Dali::PinchGesture *arg3 = 0 ;
57498   Dali::Actor *argp2 ;
57499
57500   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57501   argp2 = (Dali::Actor *)jarg2;
57502   if (!argp2) {
57503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57504     return ;
57505   }
57506   arg2 = *argp2;
57507   arg3 = (Dali::PinchGesture *)jarg3;
57508   if (!arg3) {
57509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57510     return ;
57511   }
57512   {
57513     try {
57514       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57515     } catch (std::out_of_range& e) {
57516       {
57517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57518       };
57519     } catch (std::exception& e) {
57520       {
57521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57522       };
57523     } catch (Dali::DaliException e) {
57524       {
57525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57526       };
57527     } catch (...) {
57528       {
57529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57530       };
57531     }
57532   }
57533
57534 }
57535
57536
57537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57538   void * jresult ;
57539   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57540
57541   {
57542     try {
57543       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
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 = (void *)result;
57564   return jresult;
57565 }
57566
57567
57568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57569   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57570
57571   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57572   {
57573     try {
57574       delete arg1;
57575     } catch (std::out_of_range& e) {
57576       {
57577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57578       };
57579     } catch (std::exception& e) {
57580       {
57581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57582       };
57583     } catch (Dali::DaliException e) {
57584       {
57585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57586       };
57587     } catch (...) {
57588       {
57589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57590       };
57591     }
57592   }
57593
57594 }
57595
57596
57597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57598   unsigned int jresult ;
57599   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57600   bool result;
57601
57602   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57603   {
57604     try {
57605       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);
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 = result;
57626   return jresult;
57627 }
57628
57629
57630 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57631   unsigned long jresult ;
57632   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57633   std::size_t result;
57634
57635   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57636   {
57637     try {
57638       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);
57639     } catch (std::out_of_range& e) {
57640       {
57641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57642       };
57643     } catch (std::exception& e) {
57644       {
57645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57646       };
57647     } catch (Dali::DaliException e) {
57648       {
57649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57650       };
57651     } catch (...) {
57652       {
57653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57654       };
57655     }
57656   }
57657
57658   jresult = (unsigned long)result;
57659   return jresult;
57660 }
57661
57662
57663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57664   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57665   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57666
57667   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57668   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57669   {
57670     try {
57671       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57672     } catch (std::out_of_range& e) {
57673       {
57674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57675       };
57676     } catch (std::exception& e) {
57677       {
57678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57679       };
57680     } catch (Dali::DaliException e) {
57681       {
57682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57683       };
57684     } catch (...) {
57685       {
57686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57687       };
57688     }
57689   }
57690
57691 }
57692
57693
57694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57695   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57696   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57697
57698   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57699   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57700   {
57701     try {
57702       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57703     } catch (std::out_of_range& e) {
57704       {
57705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57706       };
57707     } catch (std::exception& e) {
57708       {
57709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57710       };
57711     } catch (Dali::DaliException e) {
57712       {
57713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57714       };
57715     } catch (...) {
57716       {
57717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57718       };
57719     }
57720   }
57721
57722 }
57723
57724
57725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57726   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57727   Dali::Actor arg2 ;
57728   Dali::TapGesture *arg3 = 0 ;
57729   Dali::Actor *argp2 ;
57730
57731   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57732   argp2 = (Dali::Actor *)jarg2;
57733   if (!argp2) {
57734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57735     return ;
57736   }
57737   arg2 = *argp2;
57738   arg3 = (Dali::TapGesture *)jarg3;
57739   if (!arg3) {
57740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57741     return ;
57742   }
57743   {
57744     try {
57745       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57746     } catch (std::out_of_range& e) {
57747       {
57748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57749       };
57750     } catch (std::exception& e) {
57751       {
57752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57753       };
57754     } catch (Dali::DaliException e) {
57755       {
57756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57757       };
57758     } catch (...) {
57759       {
57760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57761       };
57762     }
57763   }
57764
57765 }
57766
57767
57768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57769   void * jresult ;
57770   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57771
57772   {
57773     try {
57774       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57775     } catch (std::out_of_range& e) {
57776       {
57777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57778       };
57779     } catch (std::exception& e) {
57780       {
57781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57782       };
57783     } catch (Dali::DaliException e) {
57784       {
57785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57786       };
57787     } catch (...) {
57788       {
57789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57790       };
57791     }
57792   }
57793
57794   jresult = (void *)result;
57795   return jresult;
57796 }
57797
57798
57799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57800   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57801
57802   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57803   {
57804     try {
57805       delete arg1;
57806     } catch (std::out_of_range& e) {
57807       {
57808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57809       };
57810     } catch (std::exception& e) {
57811       {
57812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57813       };
57814     } catch (Dali::DaliException e) {
57815       {
57816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57817       };
57818     } catch (...) {
57819       {
57820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57821       };
57822     }
57823   }
57824
57825 }
57826
57827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57828   unsigned int jresult ;
57829   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57830   bool result;
57831
57832   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57833   {
57834     try {
57835       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57836     } catch (std::out_of_range& e) {
57837       {
57838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57839       };
57840     } catch (std::exception& e) {
57841       {
57842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57843       };
57844     } catch (Dali::DaliException e) {
57845       {
57846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57847       };
57848     } catch (...) {
57849       {
57850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57851       };
57852     }
57853   }
57854
57855   jresult = result;
57856   return jresult;
57857 }
57858
57859
57860 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57861   unsigned long jresult ;
57862   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57863   std::size_t result;
57864
57865   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57866   {
57867     try {
57868       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57869     } catch (std::out_of_range& e) {
57870       {
57871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57872       };
57873     } catch (std::exception& e) {
57874       {
57875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57876       };
57877     } catch (Dali::DaliException e) {
57878       {
57879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57880       };
57881     } catch (...) {
57882       {
57883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57884       };
57885     }
57886   }
57887
57888   jresult = (unsigned long)result;
57889   return jresult;
57890 }
57891
57892
57893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57894   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57895   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57896
57897   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57898   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57899   {
57900     try {
57901       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57902     } catch (std::out_of_range& e) {
57903       {
57904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57905       };
57906     } catch (std::exception& e) {
57907       {
57908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57909       };
57910     } catch (Dali::DaliException e) {
57911       {
57912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57913       };
57914     } catch (...) {
57915       {
57916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57917       };
57918     }
57919   }
57920
57921 }
57922
57923
57924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57925   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57926   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57927
57928   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57929   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57930   {
57931     try {
57932       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57933     } catch (std::out_of_range& e) {
57934       {
57935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57936       };
57937     } catch (std::exception& e) {
57938       {
57939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57940       };
57941     } catch (Dali::DaliException e) {
57942       {
57943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57944       };
57945     } catch (...) {
57946       {
57947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57948       };
57949     }
57950   }
57951
57952 }
57953
57954
57955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57956   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57957   Dali::ResourceImage arg2 ;
57958   Dali::ResourceImage *argp2 ;
57959
57960   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57961   argp2 = (Dali::ResourceImage *)jarg2;
57962   if (!argp2) {
57963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57964     return ;
57965   }
57966   arg2 = *argp2;
57967   {
57968     try {
57969       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57970     } catch (std::out_of_range& e) {
57971       {
57972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57973       };
57974     } catch (std::exception& e) {
57975       {
57976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57977       };
57978     } catch (Dali::DaliException e) {
57979       {
57980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57981       };
57982     } catch (...) {
57983       {
57984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57985       };
57986     }
57987   }
57988
57989 }
57990
57991
57992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57993   void * jresult ;
57994   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57995
57996   {
57997     try {
57998       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57999     } catch (std::out_of_range& e) {
58000       {
58001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58002       };
58003     } catch (std::exception& e) {
58004       {
58005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58006       };
58007     } catch (Dali::DaliException e) {
58008       {
58009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58010       };
58011     } catch (...) {
58012       {
58013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58014       };
58015     }
58016   }
58017
58018   jresult = (void *)result;
58019   return jresult;
58020 }
58021
58022
58023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
58024   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
58025
58026   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
58027   {
58028     try {
58029       delete arg1;
58030     } catch (std::out_of_range& e) {
58031       {
58032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58033       };
58034     } catch (std::exception& e) {
58035       {
58036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58037       };
58038     } catch (Dali::DaliException e) {
58039       {
58040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58041       };
58042     } catch (...) {
58043       {
58044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58045       };
58046     }
58047   }
58048
58049 }
58050
58051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
58052   unsigned int jresult ;
58053   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58054   bool result = false;
58055
58056   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58057   {
58058     try {
58059       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);
58060     } catch (std::out_of_range& e) {
58061       {
58062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58063       };
58064     } catch (std::exception& e) {
58065       {
58066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58067       };
58068     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58069   }
58070   jresult = result;
58071   return jresult;
58072 }
58073
58074 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
58075   unsigned long jresult ;
58076   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58077   std::size_t result = 0;
58078
58079   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58080   {
58081     try {
58082       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);
58083     } catch (std::out_of_range& e) {
58084       {
58085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58086       };
58087     } catch (std::exception& e) {
58088       {
58089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58090       };
58091     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58092   }
58093   jresult = (unsigned long)result;
58094   return jresult;
58095 }
58096
58097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58098   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58099   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58100
58101   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58102   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58103   {
58104     try {
58105       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58106     } catch (std::out_of_range& e) {
58107       {
58108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58109       };
58110     } catch (std::exception& e) {
58111       {
58112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58113       };
58114     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58115   }
58116 }
58117
58118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58119   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58120   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58121
58122   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58123   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58124   {
58125     try {
58126       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58127     } catch (std::out_of_range& e) {
58128       {
58129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58130       };
58131     } catch (std::exception& e) {
58132       {
58133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58134       };
58135     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58136   }
58137 }
58138
58139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58140   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58141   Dali::Actor arg2 ;
58142   //bool arg3 ;
58143   Dali::LayoutDirection::Type arg4 ;
58144   Dali::Actor *argp2 ;
58145
58146   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58147   argp2 = (Dali::Actor *)jarg2;
58148   if (!argp2) {
58149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58150     return ;
58151   }
58152   arg2 = *argp2;
58153   //arg3 = jarg3 ? true : false;
58154   arg4 = (Dali::LayoutDirection::Type)jarg4;
58155   {
58156     try {
58157       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58158     } catch (std::out_of_range& e) {
58159       {
58160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58161       };
58162     } catch (std::exception& e) {
58163       {
58164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58165       };
58166     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58167   }
58168 }
58169
58170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58171   void * jresult ;
58172   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58173
58174   {
58175     try {
58176       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58177     } catch (std::out_of_range& e) {
58178       {
58179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58180       };
58181     } catch (std::exception& e) {
58182       {
58183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58184       };
58185     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58186   }
58187   jresult = (void *)result;
58188   return jresult;
58189 }
58190
58191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58192   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58193
58194   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58195   {
58196     try {
58197       delete arg1;
58198     } catch (std::out_of_range& e) {
58199       {
58200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58201       };
58202     } catch (std::exception& e) {
58203       {
58204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58205       };
58206     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58207   }
58208 }
58209
58210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58211   unsigned int jresult ;
58212   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58213   bool result;
58214
58215   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58216   {
58217     try {
58218       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);
58219     } catch (std::out_of_range& e) {
58220       {
58221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58222       };
58223     } catch (std::exception& e) {
58224       {
58225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58226       };
58227     } catch (Dali::DaliException e) {
58228       {
58229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58230       };
58231     } catch (...) {
58232       {
58233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58234       };
58235     }
58236   }
58237
58238   jresult = result;
58239   return jresult;
58240 }
58241
58242
58243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58244   unsigned long jresult ;
58245   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58246   std::size_t result;
58247
58248   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58249   {
58250     try {
58251       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);
58252     } catch (std::out_of_range& e) {
58253       {
58254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58255       };
58256     } catch (std::exception& e) {
58257       {
58258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58259       };
58260     } catch (Dali::DaliException e) {
58261       {
58262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58263       };
58264     } catch (...) {
58265       {
58266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58267       };
58268     }
58269   }
58270
58271   jresult = (unsigned long)result;
58272   return jresult;
58273 }
58274
58275
58276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58277   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58278   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58279
58280   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58281   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58282   {
58283     try {
58284       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58285     } catch (std::out_of_range& e) {
58286       {
58287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58288       };
58289     } catch (std::exception& e) {
58290       {
58291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58292       };
58293     } catch (Dali::DaliException e) {
58294       {
58295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58296       };
58297     } catch (...) {
58298       {
58299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58300       };
58301     }
58302   }
58303
58304 }
58305
58306
58307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58308   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58309   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58310
58311   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58312   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58313   {
58314     try {
58315       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58316     } catch (std::out_of_range& e) {
58317       {
58318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58319       };
58320     } catch (std::exception& e) {
58321       {
58322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58323       };
58324     } catch (Dali::DaliException e) {
58325       {
58326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58327       };
58328     } catch (...) {
58329       {
58330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58331       };
58332     }
58333   }
58334
58335 }
58336
58337
58338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58339   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58340   Dali::Actor arg2 ;
58341   bool arg3 ;
58342   Dali::DevelActor::VisibilityChange::Type arg4 ;
58343   Dali::Actor *argp2 ;
58344
58345   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58346   argp2 = (Dali::Actor *)jarg2;
58347   if (!argp2) {
58348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58349     return ;
58350   }
58351   arg2 = *argp2;
58352   arg3 = jarg3 ? true : false;
58353   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58354   {
58355     try {
58356       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58357     } catch (std::out_of_range& e) {
58358       {
58359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58360       };
58361     } catch (std::exception& e) {
58362       {
58363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58364       };
58365     } catch (Dali::DaliException e) {
58366       {
58367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58368       };
58369     } catch (...) {
58370       {
58371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58372       };
58373     }
58374   }
58375
58376 }
58377
58378
58379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58380   void * jresult ;
58381   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58382
58383   {
58384     try {
58385       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58386     } catch (std::out_of_range& e) {
58387       {
58388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58389       };
58390     } catch (std::exception& e) {
58391       {
58392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58393       };
58394     } catch (Dali::DaliException e) {
58395       {
58396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58397       };
58398     } catch (...) {
58399       {
58400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58401       };
58402     }
58403   }
58404
58405   jresult = (void *)result;
58406   return jresult;
58407 }
58408
58409
58410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58411   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58412
58413   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58414   {
58415     try {
58416       delete arg1;
58417     } catch (std::out_of_range& e) {
58418       {
58419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58420       };
58421     } catch (std::exception& e) {
58422       {
58423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58424       };
58425     } catch (Dali::DaliException e) {
58426       {
58427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58428       };
58429     } catch (...) {
58430       {
58431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58432       };
58433     }
58434   }
58435
58436 }
58437
58438
58439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58440   void * jresult ;
58441   Dali::Timer *result = 0 ;
58442
58443   {
58444     try {
58445       result = (Dali::Timer *)new Dali::Timer();
58446     } catch (std::out_of_range& e) {
58447       {
58448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58449       };
58450     } catch (std::exception& e) {
58451       {
58452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58453       };
58454     } catch (Dali::DaliException e) {
58455       {
58456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58457       };
58458     } catch (...) {
58459       {
58460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58461       };
58462     }
58463   }
58464
58465   jresult = (void *)result;
58466   return jresult;
58467 }
58468
58469
58470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58471   void * jresult ;
58472   unsigned int arg1 ;
58473   Dali::Timer result;
58474
58475   arg1 = (unsigned int)jarg1;
58476   {
58477     try {
58478       result = Dali::Timer::New(arg1);
58479     } catch (std::out_of_range& e) {
58480       {
58481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58482       };
58483     } catch (std::exception& e) {
58484       {
58485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58486       };
58487     } catch (Dali::DaliException e) {
58488       {
58489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58490       };
58491     } catch (...) {
58492       {
58493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58494       };
58495     }
58496   }
58497
58498   jresult = new Dali::Timer((const Dali::Timer &)result);
58499   return jresult;
58500 }
58501
58502
58503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58504   void * jresult ;
58505   Dali::Timer *arg1 = 0 ;
58506   Dali::Timer *result = 0 ;
58507
58508   arg1 = (Dali::Timer *)jarg1;
58509   if (!arg1) {
58510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58511     return 0;
58512   }
58513   {
58514     try {
58515       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58516     } catch (std::out_of_range& e) {
58517       {
58518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58519       };
58520     } catch (std::exception& e) {
58521       {
58522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58523       };
58524     } catch (Dali::DaliException e) {
58525       {
58526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58527       };
58528     } catch (...) {
58529       {
58530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58531       };
58532     }
58533   }
58534
58535   jresult = (void *)result;
58536   return jresult;
58537 }
58538
58539
58540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58541   void * jresult ;
58542   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58543   Dali::Timer *arg2 = 0 ;
58544   Dali::Timer *result = 0 ;
58545
58546   arg1 = (Dali::Timer *)jarg1;
58547   arg2 = (Dali::Timer *)jarg2;
58548   if (!arg2) {
58549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58550     return 0;
58551   }
58552   {
58553     try {
58554       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58555     } catch (std::out_of_range& e) {
58556       {
58557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58558       };
58559     } catch (std::exception& e) {
58560       {
58561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58562       };
58563     } catch (Dali::DaliException e) {
58564       {
58565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58566       };
58567     } catch (...) {
58568       {
58569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58570       };
58571     }
58572   }
58573
58574   jresult = (void *)result;
58575   return jresult;
58576 }
58577
58578
58579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58580   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58581
58582   arg1 = (Dali::Timer *)jarg1;
58583   {
58584     try {
58585       delete arg1;
58586     } catch (std::out_of_range& e) {
58587       {
58588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58589       };
58590     } catch (std::exception& e) {
58591       {
58592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58593       };
58594     } catch (Dali::DaliException e) {
58595       {
58596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58597       };
58598     } catch (...) {
58599       {
58600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58601       };
58602     }
58603   }
58604
58605 }
58606
58607
58608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58609   void * jresult ;
58610   Dali::BaseHandle arg1 ;
58611   Dali::BaseHandle *argp1 ;
58612   Dali::Timer result;
58613
58614   argp1 = (Dali::BaseHandle *)jarg1;
58615   if (!argp1) {
58616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58617     return 0;
58618   }
58619   arg1 = *argp1;
58620   {
58621     try {
58622       result = Dali::Timer::DownCast(arg1);
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 = new Dali::Timer((const Dali::Timer &)result);
58643   return jresult;
58644 }
58645
58646
58647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58648   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58649
58650   arg1 = (Dali::Timer *)jarg1;
58651   {
58652     try {
58653       (arg1)->Start();
58654     } catch (std::out_of_range& e) {
58655       {
58656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58657       };
58658     } catch (std::exception& e) {
58659       {
58660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58661       };
58662     } catch (Dali::DaliException e) {
58663       {
58664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58665       };
58666     } catch (...) {
58667       {
58668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58669       };
58670     }
58671   }
58672
58673 }
58674
58675
58676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58677   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58678
58679   arg1 = (Dali::Timer *)jarg1;
58680   {
58681     try {
58682       (arg1)->Stop();
58683     } catch (std::out_of_range& e) {
58684       {
58685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58686       };
58687     } catch (std::exception& e) {
58688       {
58689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58690       };
58691     } catch (Dali::DaliException e) {
58692       {
58693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58694       };
58695     } catch (...) {
58696       {
58697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58698       };
58699     }
58700   }
58701
58702 }
58703
58704
58705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58706   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58707   unsigned int arg2 ;
58708
58709   arg1 = (Dali::Timer *)jarg1;
58710   arg2 = (unsigned int)jarg2;
58711   {
58712     try {
58713       (arg1)->SetInterval(arg2);
58714     } catch (std::out_of_range& e) {
58715       {
58716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58717       };
58718     } catch (std::exception& e) {
58719       {
58720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58721       };
58722     } catch (Dali::DaliException e) {
58723       {
58724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58725       };
58726     } catch (...) {
58727       {
58728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58729       };
58730     }
58731   }
58732
58733 }
58734
58735
58736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58737   unsigned int jresult ;
58738   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58739   unsigned int result;
58740
58741   arg1 = (Dali::Timer *)jarg1;
58742   {
58743     try {
58744       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58745     } catch (std::out_of_range& e) {
58746       {
58747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58748       };
58749     } catch (std::exception& e) {
58750       {
58751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58752       };
58753     } catch (Dali::DaliException e) {
58754       {
58755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58756       };
58757     } catch (...) {
58758       {
58759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58760       };
58761     }
58762   }
58763
58764   jresult = result;
58765   return jresult;
58766 }
58767
58768
58769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58770   unsigned int jresult ;
58771   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58772   bool result;
58773
58774   arg1 = (Dali::Timer *)jarg1;
58775   {
58776     try {
58777       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
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 = result;
58798   return jresult;
58799 }
58800
58801
58802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58803   void * jresult ;
58804   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58805   Dali::Timer::TimerSignalType *result = 0 ;
58806
58807   arg1 = (Dali::Timer *)jarg1;
58808   {
58809     try {
58810       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58811     } catch (std::out_of_range& e) {
58812       {
58813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58814       };
58815     } catch (std::exception& e) {
58816       {
58817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58818       };
58819     } catch (Dali::DaliException e) {
58820       {
58821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58822       };
58823     } catch (...) {
58824       {
58825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58826       };
58827     }
58828   }
58829
58830   jresult = (void *)result;
58831   return jresult;
58832 }
58833
58834
58835 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58836   unsigned int jresult ;
58837   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58838   bool result;
58839
58840   arg1 = (Dali::Signal< bool () > *)jarg1;
58841   {
58842     try {
58843       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58844     } catch (std::out_of_range& e) {
58845       {
58846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58847       };
58848     } catch (std::exception& e) {
58849       {
58850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58851       };
58852     } catch (Dali::DaliException e) {
58853       {
58854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58855       };
58856     } catch (...) {
58857       {
58858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58859       };
58860     }
58861   }
58862
58863   jresult = result;
58864   return jresult;
58865 }
58866
58867
58868 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58869   unsigned long jresult ;
58870   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58871   std::size_t result;
58872
58873   arg1 = (Dali::Signal< bool () > *)jarg1;
58874   {
58875     try {
58876       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58877     } catch (std::out_of_range& e) {
58878       {
58879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58880       };
58881     } catch (std::exception& e) {
58882       {
58883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58884       };
58885     } catch (Dali::DaliException e) {
58886       {
58887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58888       };
58889     } catch (...) {
58890       {
58891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58892       };
58893     }
58894   }
58895
58896   jresult = (unsigned long)result;
58897   return jresult;
58898 }
58899
58900
58901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58902   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58903   bool (*arg2)() = (bool (*)()) 0 ;
58904
58905   arg1 = (Dali::Signal< bool () > *)jarg1;
58906   arg2 = (bool (*)())jarg2;
58907   {
58908     try {
58909       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58910     } catch (std::out_of_range& e) {
58911       {
58912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58913       };
58914     } catch (std::exception& e) {
58915       {
58916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58917       };
58918     } catch (Dali::DaliException e) {
58919       {
58920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58921       };
58922     } catch (...) {
58923       {
58924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58925       };
58926     }
58927   }
58928
58929 }
58930
58931
58932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58933   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58934   bool (*arg2)() = (bool (*)()) 0 ;
58935
58936   arg1 = (Dali::Signal< bool () > *)jarg1;
58937   arg2 = (bool (*)())jarg2;
58938   {
58939     try {
58940       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58941     } catch (std::out_of_range& e) {
58942       {
58943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58944       };
58945     } catch (std::exception& e) {
58946       {
58947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58948       };
58949     } catch (Dali::DaliException e) {
58950       {
58951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58952       };
58953     } catch (...) {
58954       {
58955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58956       };
58957     }
58958   }
58959
58960 }
58961
58962
58963 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58964   unsigned int jresult ;
58965   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58966   bool result;
58967
58968   arg1 = (Dali::Signal< bool () > *)jarg1;
58969   {
58970     try {
58971       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58972     } catch (std::out_of_range& e) {
58973       {
58974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58975       };
58976     } catch (std::exception& e) {
58977       {
58978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58979       };
58980     } catch (Dali::DaliException e) {
58981       {
58982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58983       };
58984     } catch (...) {
58985       {
58986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58987       };
58988     }
58989   }
58990
58991   jresult = result;
58992   return jresult;
58993 }
58994
58995
58996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
58997   void * jresult ;
58998   Dali::Signal< bool () > *result = 0 ;
58999
59000   {
59001     try {
59002       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59003     } catch (std::out_of_range& e) {
59004       {
59005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59006       };
59007     } catch (std::exception& e) {
59008       {
59009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59010       };
59011     } catch (Dali::DaliException e) {
59012       {
59013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59014       };
59015     } catch (...) {
59016       {
59017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59018       };
59019     }
59020   }
59021
59022   jresult = (void *)result;
59023   return jresult;
59024 }
59025
59026
59027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59028   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59029
59030   arg1 = (Dali::Signal< bool () > *)jarg1;
59031   {
59032     try {
59033       delete arg1;
59034     } catch (std::out_of_range& e) {
59035       {
59036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59037       };
59038     } catch (std::exception& e) {
59039       {
59040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59041       };
59042     } catch (Dali::DaliException e) {
59043       {
59044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59045       };
59046     } catch (...) {
59047       {
59048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59049       };
59050     }
59051   }
59052
59053 }
59054
59055
59056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59057   int jresult ;
59058   int result;
59059
59060   {
59061     try {
59062       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59063     } catch (std::out_of_range& e) {
59064       {
59065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59066       };
59067     } catch (std::exception& e) {
59068       {
59069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59070       };
59071     } catch (Dali::DaliException e) {
59072       {
59073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59074       };
59075     } catch (...) {
59076       {
59077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59078       };
59079     }
59080   }
59081
59082   jresult = (int)result;
59083   return jresult;
59084 }
59085
59086
59087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59088   int jresult ;
59089   int result;
59090
59091   {
59092     try {
59093       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59094     } catch (std::out_of_range& e) {
59095       {
59096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59097       };
59098     } catch (std::exception& e) {
59099       {
59100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59101       };
59102     } catch (Dali::DaliException e) {
59103       {
59104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59105       };
59106     } catch (...) {
59107       {
59108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59109       };
59110     }
59111   }
59112
59113   jresult = (int)result;
59114   return jresult;
59115 }
59116
59117
59118 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59119   int jresult ;
59120   int result;
59121
59122   {
59123     try {
59124       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59125     } catch (std::out_of_range& e) {
59126       {
59127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59128       };
59129     } catch (std::exception& e) {
59130       {
59131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59132       };
59133     } catch (Dali::DaliException e) {
59134       {
59135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59136       };
59137     } catch (...) {
59138       {
59139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59140       };
59141     }
59142   }
59143
59144   jresult = (int)result;
59145   return jresult;
59146 }
59147
59148
59149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59150   int jresult ;
59151   int result;
59152
59153   {
59154     try {
59155       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59156     } catch (std::out_of_range& e) {
59157       {
59158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59159       };
59160     } catch (std::exception& e) {
59161       {
59162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59163       };
59164     } catch (Dali::DaliException e) {
59165       {
59166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59167       };
59168     } catch (...) {
59169       {
59170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59171       };
59172     }
59173   }
59174
59175   jresult = (int)result;
59176   return jresult;
59177 }
59178
59179
59180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59181   int jresult ;
59182   int result;
59183
59184   {
59185     try {
59186       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59187     } catch (std::out_of_range& e) {
59188       {
59189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59190       };
59191     } catch (std::exception& e) {
59192       {
59193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59194       };
59195     } catch (Dali::DaliException e) {
59196       {
59197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59198       };
59199     } catch (...) {
59200       {
59201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59202       };
59203     }
59204   }
59205
59206   jresult = (int)result;
59207   return jresult;
59208 }
59209
59210
59211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59212   int jresult ;
59213   int result;
59214
59215   {
59216     try {
59217       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59218     } catch (std::out_of_range& e) {
59219       {
59220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59221       };
59222     } catch (std::exception& e) {
59223       {
59224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59225       };
59226     } catch (Dali::DaliException e) {
59227       {
59228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59229       };
59230     } catch (...) {
59231       {
59232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59233       };
59234     }
59235   }
59236
59237   jresult = (int)result;
59238   return jresult;
59239 }
59240
59241
59242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59243   int jresult ;
59244   int result;
59245
59246   {
59247     try {
59248       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59249     } catch (std::out_of_range& e) {
59250       {
59251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59252       };
59253     } catch (std::exception& e) {
59254       {
59255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59256       };
59257     } catch (Dali::DaliException e) {
59258       {
59259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59260       };
59261     } catch (...) {
59262       {
59263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59264       };
59265     }
59266   }
59267
59268   jresult = (int)result;
59269   return jresult;
59270 }
59271
59272
59273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59274   int jresult ;
59275   int result;
59276
59277   {
59278     try {
59279       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59280     } catch (std::out_of_range& e) {
59281       {
59282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59283       };
59284     } catch (std::exception& e) {
59285       {
59286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59287       };
59288     } catch (Dali::DaliException e) {
59289       {
59290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59291       };
59292     } catch (...) {
59293       {
59294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59295       };
59296     }
59297   }
59298
59299   jresult = (int)result;
59300   return jresult;
59301 }
59302
59303
59304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59305   int jresult ;
59306   int result;
59307
59308   {
59309     try {
59310       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59311     } catch (std::out_of_range& e) {
59312       {
59313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59314       };
59315     } catch (std::exception& e) {
59316       {
59317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59318       };
59319     } catch (Dali::DaliException e) {
59320       {
59321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59322       };
59323     } catch (...) {
59324       {
59325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59326       };
59327     }
59328   }
59329
59330   jresult = (int)result;
59331   return jresult;
59332 }
59333
59334
59335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59336   int jresult ;
59337   int result;
59338
59339   {
59340     try {
59341       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59342     } catch (std::out_of_range& e) {
59343       {
59344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59345       };
59346     } catch (std::exception& e) {
59347       {
59348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59349       };
59350     } catch (Dali::DaliException e) {
59351       {
59352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59353       };
59354     } catch (...) {
59355       {
59356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59357       };
59358     }
59359   }
59360
59361   jresult = (int)result;
59362   return jresult;
59363 }
59364
59365
59366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59367   int jresult ;
59368   int result;
59369
59370   {
59371     try {
59372       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59373     } catch (std::out_of_range& e) {
59374       {
59375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59376       };
59377     } catch (std::exception& e) {
59378       {
59379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59380       };
59381     } catch (Dali::DaliException e) {
59382       {
59383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59384       };
59385     } catch (...) {
59386       {
59387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59388       };
59389     }
59390   }
59391
59392   jresult = (int)result;
59393   return jresult;
59394 }
59395
59396
59397 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59398   int jresult ;
59399   int result;
59400
59401   {
59402     try {
59403       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59404     } catch (std::out_of_range& e) {
59405       {
59406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59407       };
59408     } catch (std::exception& e) {
59409       {
59410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59411       };
59412     } catch (Dali::DaliException e) {
59413       {
59414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59415       };
59416     } catch (...) {
59417       {
59418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59419       };
59420     }
59421   }
59422
59423   jresult = (int)result;
59424   return jresult;
59425 }
59426
59427
59428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59429   int jresult ;
59430   int result;
59431
59432   {
59433     try {
59434       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59435     } catch (std::out_of_range& e) {
59436       {
59437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59438       };
59439     } catch (std::exception& e) {
59440       {
59441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59442       };
59443     } catch (Dali::DaliException e) {
59444       {
59445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59446       };
59447     } catch (...) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59450       };
59451     }
59452   }
59453
59454   jresult = (int)result;
59455   return jresult;
59456 }
59457
59458
59459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59460   int jresult ;
59461   int result;
59462
59463   {
59464     try {
59465       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59466     } catch (std::out_of_range& e) {
59467       {
59468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59469       };
59470     } catch (std::exception& e) {
59471       {
59472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59473       };
59474     } catch (Dali::DaliException e) {
59475       {
59476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59477       };
59478     } catch (...) {
59479       {
59480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59481       };
59482     }
59483   }
59484
59485   jresult = (int)result;
59486   return jresult;
59487 }
59488
59489
59490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59491   int jresult ;
59492   int result;
59493
59494   {
59495     try {
59496       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59497     } catch (std::out_of_range& e) {
59498       {
59499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59500       };
59501     } catch (std::exception& e) {
59502       {
59503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59504       };
59505     } catch (Dali::DaliException e) {
59506       {
59507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59508       };
59509     } catch (...) {
59510       {
59511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59512       };
59513     }
59514   }
59515
59516   jresult = (int)result;
59517   return jresult;
59518 }
59519
59520
59521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59522   int jresult ;
59523   int result;
59524
59525   {
59526     try {
59527       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59528     } catch (std::out_of_range& e) {
59529       {
59530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59531       };
59532     } catch (std::exception& e) {
59533       {
59534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59535       };
59536     } catch (Dali::DaliException e) {
59537       {
59538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59539       };
59540     } catch (...) {
59541       {
59542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59543       };
59544     }
59545   }
59546
59547   jresult = (int)result;
59548   return jresult;
59549 }
59550
59551
59552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59553   int jresult ;
59554   int result;
59555
59556   {
59557     try {
59558       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59559     } catch (std::out_of_range& e) {
59560       {
59561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59562       };
59563     } catch (std::exception& e) {
59564       {
59565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59566       };
59567     } catch (Dali::DaliException e) {
59568       {
59569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59570       };
59571     } catch (...) {
59572       {
59573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59574       };
59575     }
59576   }
59577
59578   jresult = (int)result;
59579   return jresult;
59580 }
59581
59582
59583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59584   int jresult ;
59585   int result;
59586
59587   {
59588     try {
59589       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59590     } catch (std::out_of_range& e) {
59591       {
59592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59593       };
59594     } catch (std::exception& e) {
59595       {
59596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59597       };
59598     } catch (Dali::DaliException e) {
59599       {
59600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59601       };
59602     } catch (...) {
59603       {
59604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59605       };
59606     }
59607   }
59608
59609   jresult = (int)result;
59610   return jresult;
59611 }
59612
59613
59614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59615   int jresult ;
59616   int result;
59617
59618   {
59619     try {
59620       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59621     } catch (std::out_of_range& e) {
59622       {
59623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59624       };
59625     } catch (std::exception& e) {
59626       {
59627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59628       };
59629     } catch (Dali::DaliException e) {
59630       {
59631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59632       };
59633     } catch (...) {
59634       {
59635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59636       };
59637     }
59638   }
59639
59640   jresult = (int)result;
59641   return jresult;
59642 }
59643
59644
59645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59646   int jresult ;
59647   int result;
59648
59649   {
59650     try {
59651       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59652     } catch (std::out_of_range& e) {
59653       {
59654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59655       };
59656     } catch (std::exception& e) {
59657       {
59658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59659       };
59660     } catch (Dali::DaliException e) {
59661       {
59662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59663       };
59664     } catch (...) {
59665       {
59666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59667       };
59668     }
59669   }
59670
59671   jresult = (int)result;
59672   return jresult;
59673 }
59674
59675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59676   int jresult ;
59677   int result;
59678
59679   {
59680     try {
59681       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59682     } catch (std::out_of_range& e) {
59683       {
59684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59685       };
59686     } catch (std::exception& e) {
59687       {
59688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59689       };
59690     } catch (Dali::DaliException e) {
59691       {
59692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59693       };
59694     } catch (...) {
59695       {
59696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59697       };
59698     }
59699   }
59700
59701   jresult = (int)result;
59702   return jresult;
59703 }
59704
59705
59706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59707   int jresult ;
59708   int result;
59709   {
59710     try
59711     {
59712       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59713     } catch (std::out_of_range& e) {
59714       {
59715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59716       };
59717     } catch (std::exception& e) {
59718       {
59719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59720       };
59721     } catch (Dali::DaliException e) {
59722       {
59723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59724       };
59725     } catch (...) {
59726       {
59727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59728       };
59729     }
59730   }
59731
59732   jresult = (int)result;
59733   return jresult;
59734 }
59735
59736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59737   int jresult ;
59738   int result;
59739   {
59740     try
59741     {
59742       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59743     } catch (std::out_of_range& e) {
59744       {
59745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59746       };
59747     } catch (std::exception& e) {
59748       {
59749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59750       };
59751     } catch (Dali::DaliException e) {
59752       {
59753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59754       };
59755     } catch (...) {
59756       {
59757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59758       };
59759     }
59760   }
59761
59762   jresult = (int)result;
59763   return jresult;
59764 }
59765
59766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59767   int jresult ;
59768   int result;
59769   {
59770     try
59771     {
59772       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59773     } catch (std::out_of_range& e) {
59774       {
59775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59776       };
59777     } catch (std::exception& e) {
59778       {
59779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59780       };
59781     } catch (Dali::DaliException e) {
59782       {
59783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59784       };
59785     } catch (...) {
59786       {
59787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59788       };
59789     }
59790   }
59791
59792   jresult = (int)result;
59793   return jresult;
59794 }
59795
59796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59797   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59798 }
59799
59800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59801   int jresult ;
59802   int result;
59803   {
59804     try
59805     {
59806       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59807     } catch (std::out_of_range& e) {
59808       {
59809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59810       };
59811     } catch (std::exception& e) {
59812       {
59813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59814       };
59815     } catch (Dali::DaliException e) {
59816       {
59817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59818       };
59819     } catch (...) {
59820       {
59821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59822       };
59823     }
59824   }
59825
59826   jresult = (int)result;
59827   return jresult;
59828 }
59829
59830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59831   int jresult ;
59832   int result;
59833   {
59834     try
59835     {
59836       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59837     } catch (std::out_of_range& e) {
59838       {
59839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59840       };
59841     } catch (std::exception& e) {
59842       {
59843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59844       };
59845     } catch (Dali::DaliException e) {
59846       {
59847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59848       };
59849     } catch (...) {
59850       {
59851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59852       };
59853     }
59854   }
59855
59856   jresult = (int)result;
59857   return jresult;
59858 }
59859
59860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59861   int jresult ;
59862   int result;
59863
59864   {
59865     try {
59866       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59867     } catch (std::out_of_range& e) {
59868       {
59869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59870       };
59871     } catch (std::exception& e) {
59872       {
59873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59874       };
59875     } catch (Dali::DaliException e) {
59876       {
59877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59878       };
59879     } catch (...) {
59880       {
59881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59882       };
59883     }
59884   }
59885
59886   jresult = (int)result;
59887   return jresult;
59888 }
59889
59890
59891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59892   int jresult ;
59893   int result;
59894
59895   {
59896     try {
59897       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59898     } catch (std::out_of_range& e) {
59899       {
59900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59901       };
59902     } catch (std::exception& e) {
59903       {
59904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59905       };
59906     } catch (Dali::DaliException e) {
59907       {
59908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59909       };
59910     } catch (...) {
59911       {
59912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59913       };
59914     }
59915   }
59916
59917   jresult = (int)result;
59918   return jresult;
59919 }
59920
59921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59922   int jresult ;
59923   int result;
59924   {
59925     try
59926     {
59927       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59928     } catch (std::out_of_range& e) {
59929       {
59930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59931       };
59932     } catch (std::exception& e) {
59933       {
59934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59935       };
59936     } catch (...) {
59937       {
59938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59939       };
59940     }
59941   }
59942   jresult = (int)result;
59943   return jresult;
59944 }
59945
59946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59947   int jresult ;
59948   int result;
59949   {
59950     try
59951     {
59952       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59953     } catch (std::out_of_range& e) {
59954       {
59955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59956       };
59957     } catch (std::exception& e) {
59958       {
59959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59960       };
59961     } catch (...) {
59962       {
59963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59964       };
59965     }
59966   }
59967   jresult = (int)result;
59968   return jresult;
59969 }
59970
59971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59972   int jresult ;
59973   int result;
59974   {
59975     try
59976     {
59977       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59978     } catch (std::out_of_range& e) {
59979       {
59980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59981       };
59982     } catch (std::exception& e) {
59983       {
59984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59985       };
59986     } catch (...) {
59987       {
59988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59989       };
59990     }
59991   }
59992   jresult = (int)result;
59993   return jresult;
59994 }
59995
59996
59997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
59998   int jresult ;
59999   int result;
60000   {
60001     try
60002     {
60003       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60004     } catch (std::out_of_range& e) {
60005       {
60006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60007       };
60008     } catch (std::exception& e) {
60009       {
60010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60011       };
60012     } catch (...) {
60013       {
60014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60015       };
60016     }
60017   }
60018   jresult = (int)result;
60019   return jresult;
60020 }
60021
60022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60023   int jresult ;
60024   int result;
60025   {
60026     try
60027     {
60028       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60029     } catch (std::out_of_range& e) {
60030       {
60031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60032       };
60033     } catch (std::exception& e) {
60034       {
60035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60036       };
60037     } catch (...) {
60038       {
60039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60040       };
60041     }
60042   }
60043   jresult = (int)result;
60044   return jresult;
60045 }
60046
60047
60048
60049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60050   int jresult ;
60051   int result;
60052
60053   {
60054     try {
60055       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60056     } catch (std::out_of_range& e) {
60057       {
60058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60059       };
60060     } catch (std::exception& e) {
60061       {
60062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60063       };
60064     } catch (Dali::DaliException e) {
60065       {
60066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60067       };
60068     } catch (...) {
60069       {
60070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60071       };
60072     }
60073   }
60074
60075   jresult = (int)result;
60076   return jresult;
60077 }
60078
60079
60080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60081   int jresult ;
60082   int result;
60083
60084   {
60085     try {
60086       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60087     } catch (std::out_of_range& e) {
60088       {
60089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60090       };
60091     } catch (std::exception& e) {
60092       {
60093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60094       };
60095     } catch (Dali::DaliException e) {
60096       {
60097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60098       };
60099     } catch (...) {
60100       {
60101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60102       };
60103     }
60104   }
60105
60106   jresult = (int)result;
60107   return jresult;
60108 }
60109
60110
60111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60112   int jresult ;
60113   int result;
60114
60115   {
60116     try {
60117       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60118     } catch (std::out_of_range& e) {
60119       {
60120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60121       };
60122     } catch (std::exception& e) {
60123       {
60124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60125       };
60126     } catch (Dali::DaliException e) {
60127       {
60128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60129       };
60130     } catch (...) {
60131       {
60132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60133       };
60134     }
60135   }
60136
60137   jresult = (int)result;
60138   return jresult;
60139 }
60140
60141
60142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60143   int jresult ;
60144   int result;
60145
60146   {
60147     try {
60148       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60149     } catch (std::out_of_range& e) {
60150       {
60151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60152       };
60153     } catch (std::exception& e) {
60154       {
60155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60156       };
60157     } catch (Dali::DaliException e) {
60158       {
60159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60160       };
60161     } catch (...) {
60162       {
60163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60164       };
60165     }
60166   }
60167
60168   jresult = (int)result;
60169   return jresult;
60170 }
60171
60172
60173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60174   int jresult ;
60175   int result;
60176
60177   {
60178     try {
60179       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60180     } catch (std::out_of_range& e) {
60181       {
60182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60183       };
60184     } catch (std::exception& e) {
60185       {
60186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60187       };
60188     } catch (Dali::DaliException e) {
60189       {
60190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60191       };
60192     } catch (...) {
60193       {
60194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60195       };
60196     }
60197   }
60198
60199   jresult = (int)result;
60200   return jresult;
60201 }
60202
60203
60204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60205   int jresult ;
60206   int result;
60207
60208   {
60209     try {
60210       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60211     } catch (std::out_of_range& e) {
60212       {
60213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60214       };
60215     } catch (std::exception& e) {
60216       {
60217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60218       };
60219     } catch (Dali::DaliException e) {
60220       {
60221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60222       };
60223     } catch (...) {
60224       {
60225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60226       };
60227     }
60228   }
60229
60230   jresult = (int)result;
60231   return jresult;
60232 }
60233
60234
60235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60236   int jresult ;
60237   int result;
60238
60239   {
60240     try {
60241       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60242     } catch (std::out_of_range& e) {
60243       {
60244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60245       };
60246     } catch (std::exception& e) {
60247       {
60248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60249       };
60250     } catch (Dali::DaliException e) {
60251       {
60252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60253       };
60254     } catch (...) {
60255       {
60256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60257       };
60258     }
60259   }
60260
60261   jresult = (int)result;
60262   return jresult;
60263 }
60264
60265 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60266   int jresult ;
60267   int result;
60268
60269   {
60270     try {
60271       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60272     } catch (std::out_of_range& e) {
60273       {
60274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60275       };
60276     } catch (std::exception& e) {
60277       {
60278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60279       };
60280     } catch (...) {
60281       {
60282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60283       };
60284     }
60285   }
60286   jresult = (int)result;
60287   return jresult;
60288 }
60289
60290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60291   int jresult ;
60292   int result;
60293
60294   {
60295     try {
60296       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60297     } catch (std::out_of_range& e) {
60298       {
60299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60300       };
60301     } catch (std::exception& e) {
60302       {
60303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60304       };
60305     } catch (Dali::DaliException e) {
60306       {
60307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60308       };
60309     } catch (...) {
60310       {
60311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60312       };
60313     }
60314   }
60315
60316   jresult = (int)result;
60317   return jresult;
60318 }
60319
60320
60321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60322   int jresult ;
60323   int result;
60324
60325   {
60326     try {
60327       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60328     } catch (std::out_of_range& e) {
60329       {
60330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60331       };
60332     } catch (std::exception& e) {
60333       {
60334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60335       };
60336     } catch (Dali::DaliException e) {
60337       {
60338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60339       };
60340     } catch (...) {
60341       {
60342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60343       };
60344     }
60345   }
60346
60347   jresult = (int)result;
60348   return jresult;
60349 }
60350
60351
60352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60353   int jresult ;
60354   int result;
60355
60356   {
60357     try {
60358       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60359     } catch (std::out_of_range& e) {
60360       {
60361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60362       };
60363     } catch (std::exception& e) {
60364       {
60365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60366       };
60367     } catch (Dali::DaliException e) {
60368       {
60369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60370       };
60371     } catch (...) {
60372       {
60373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60374       };
60375     }
60376   }
60377
60378   jresult = (int)result;
60379   return jresult;
60380 }
60381
60382
60383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60384   int jresult ;
60385   int result;
60386
60387   {
60388     try {
60389       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60390     } catch (std::out_of_range& e) {
60391       {
60392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60393       };
60394     } catch (std::exception& e) {
60395       {
60396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60397       };
60398     } catch (Dali::DaliException e) {
60399       {
60400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60401       };
60402     } catch (...) {
60403       {
60404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60405       };
60406     }
60407   }
60408
60409   jresult = (int)result;
60410   return jresult;
60411 }
60412
60413
60414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60415   int jresult ;
60416   int result;
60417
60418   {
60419     try {
60420       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60421     } catch (std::out_of_range& e) {
60422       {
60423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60424       };
60425     } catch (std::exception& e) {
60426       {
60427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60428       };
60429     } catch (Dali::DaliException e) {
60430       {
60431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60432       };
60433     } catch (...) {
60434       {
60435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60436       };
60437     }
60438   }
60439
60440   jresult = (int)result;
60441   return jresult;
60442 }
60443
60444
60445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60446   int jresult ;
60447   int result;
60448
60449   {
60450     try {
60451       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60452     } catch (std::out_of_range& e) {
60453       {
60454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60455       };
60456     } catch (std::exception& e) {
60457       {
60458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60459       };
60460     } catch (Dali::DaliException e) {
60461       {
60462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60463       };
60464     } catch (...) {
60465       {
60466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60467       };
60468     }
60469   }
60470
60471   jresult = (int)result;
60472   return jresult;
60473 }
60474
60475
60476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60477   int jresult ;
60478   int result;
60479
60480   {
60481     try {
60482       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60483     } catch (std::out_of_range& e) {
60484       {
60485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60486       };
60487     } catch (std::exception& e) {
60488       {
60489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60490       };
60491     } catch (Dali::DaliException e) {
60492       {
60493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60494       };
60495     } catch (...) {
60496       {
60497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60498       };
60499     }
60500   }
60501
60502   jresult = (int)result;
60503   return jresult;
60504 }
60505
60506
60507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60508   int jresult ;
60509   int result;
60510
60511   {
60512     try {
60513       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
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 = (int)result;
60534   return jresult;
60535 }
60536
60537
60538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60539   int jresult ;
60540   int result;
60541
60542   {
60543     try {
60544       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60545     } catch (std::out_of_range& e) {
60546       {
60547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60548       };
60549     } catch (std::exception& e) {
60550       {
60551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60552       };
60553     } catch (Dali::DaliException e) {
60554       {
60555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60556       };
60557     } catch (...) {
60558       {
60559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60560       };
60561     }
60562   }
60563
60564   jresult = (int)result;
60565   return jresult;
60566 }
60567
60568
60569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60570   int jresult ;
60571   int result;
60572
60573   {
60574     try {
60575       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60576     } catch (std::out_of_range& e) {
60577       {
60578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60579       };
60580     } catch (std::exception& e) {
60581       {
60582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60583       };
60584     } catch (Dali::DaliException e) {
60585       {
60586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60587       };
60588     } catch (...) {
60589       {
60590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60591       };
60592     }
60593   }
60594
60595   jresult = (int)result;
60596   return jresult;
60597 }
60598
60599
60600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60601   int jresult ;
60602   int result;
60603
60604   {
60605     try {
60606       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60607     } catch (std::out_of_range& e) {
60608       {
60609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60610       };
60611     } catch (std::exception& e) {
60612       {
60613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60614       };
60615     } catch (Dali::DaliException e) {
60616       {
60617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60618       };
60619     } catch (...) {
60620       {
60621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60622       };
60623     }
60624   }
60625
60626   jresult = (int)result;
60627   return jresult;
60628 }
60629
60630
60631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60632   int jresult ;
60633   int result;
60634
60635   {
60636     try {
60637       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60638     } catch (std::out_of_range& e) {
60639       {
60640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60641       };
60642     } catch (std::exception& e) {
60643       {
60644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60645       };
60646     } catch (Dali::DaliException e) {
60647       {
60648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60649       };
60650     } catch (...) {
60651       {
60652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60653       };
60654     }
60655   }
60656
60657   jresult = (int)result;
60658   return jresult;
60659 }
60660
60661
60662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60663   int jresult ;
60664   int result;
60665
60666   {
60667     try {
60668       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60669     } catch (std::out_of_range& e) {
60670       {
60671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60672       };
60673     } catch (std::exception& e) {
60674       {
60675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60676       };
60677     } catch (Dali::DaliException e) {
60678       {
60679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60680       };
60681     } catch (...) {
60682       {
60683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60684       };
60685     }
60686   }
60687
60688   jresult = (int)result;
60689   return jresult;
60690 }
60691
60692
60693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60694   int jresult ;
60695   int result;
60696
60697   {
60698     try {
60699       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60700     } catch (std::out_of_range& e) {
60701       {
60702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60703       };
60704     } catch (std::exception& e) {
60705       {
60706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60707       };
60708     } catch (Dali::DaliException e) {
60709       {
60710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60711       };
60712     } catch (...) {
60713       {
60714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60715       };
60716     }
60717   }
60718
60719   jresult = (int)result;
60720   return jresult;
60721 }
60722
60723
60724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60725   int jresult ;
60726   int result;
60727
60728   {
60729     try {
60730       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60731     } catch (std::out_of_range& e) {
60732       {
60733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60734       };
60735     } catch (std::exception& e) {
60736       {
60737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60738       };
60739     } catch (Dali::DaliException e) {
60740       {
60741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60742       };
60743     } catch (...) {
60744       {
60745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60746       };
60747     }
60748   }
60749
60750   jresult = (int)result;
60751   return jresult;
60752 }
60753
60754
60755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60756   int jresult ;
60757   int result;
60758
60759   {
60760     try {
60761       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60762     } catch (std::out_of_range& e) {
60763       {
60764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60765       };
60766     } catch (std::exception& e) {
60767       {
60768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60769       };
60770     } catch (Dali::DaliException e) {
60771       {
60772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60773       };
60774     } catch (...) {
60775       {
60776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60777       };
60778     }
60779   }
60780
60781   jresult = (int)result;
60782   return jresult;
60783 }
60784
60785
60786 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60787   int jresult ;
60788   int result;
60789
60790   {
60791     try {
60792       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60793     } catch (std::out_of_range& e) {
60794       {
60795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60796       };
60797     } catch (std::exception& e) {
60798       {
60799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60800       };
60801     } catch (Dali::DaliException e) {
60802       {
60803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60804       };
60805     } catch (...) {
60806       {
60807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60808       };
60809     }
60810   }
60811
60812   jresult = (int)result;
60813   return jresult;
60814 }
60815
60816
60817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60818   int jresult ;
60819   int result;
60820
60821   {
60822     try {
60823       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60824     } catch (std::out_of_range& e) {
60825       {
60826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60827       };
60828     } catch (std::exception& e) {
60829       {
60830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60831       };
60832     } catch (Dali::DaliException e) {
60833       {
60834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60835       };
60836     } catch (...) {
60837       {
60838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60839       };
60840     }
60841   }
60842
60843   jresult = (int)result;
60844   return jresult;
60845 }
60846
60847
60848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60849   int jresult ;
60850   int result;
60851
60852   {
60853     try {
60854       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60855     } catch (std::out_of_range& e) {
60856       {
60857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60858       };
60859     } catch (std::exception& e) {
60860       {
60861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60862       };
60863     } catch (Dali::DaliException e) {
60864       {
60865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60866       };
60867     } catch (...) {
60868       {
60869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60870       };
60871     }
60872   }
60873
60874   jresult = (int)result;
60875   return jresult;
60876 }
60877
60878
60879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60880   int jresult ;
60881   int result;
60882
60883   {
60884     try {
60885       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60886     } catch (std::out_of_range& e) {
60887       {
60888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60889       };
60890     } catch (std::exception& e) {
60891       {
60892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60893       };
60894     } catch (Dali::DaliException e) {
60895       {
60896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60897       };
60898     } catch (...) {
60899       {
60900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60901       };
60902     }
60903   }
60904
60905   jresult = (int)result;
60906   return jresult;
60907 }
60908
60909
60910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60911   int jresult ;
60912   int result;
60913
60914   {
60915     try {
60916       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60917     } catch (std::out_of_range& e) {
60918       {
60919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60920       };
60921     } catch (std::exception& e) {
60922       {
60923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60924       };
60925     } catch (Dali::DaliException e) {
60926       {
60927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60928       };
60929     } catch (...) {
60930       {
60931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60932       };
60933     }
60934   }
60935
60936   jresult = (int)result;
60937   return jresult;
60938 }
60939
60940
60941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60942   int jresult ;
60943   int result;
60944
60945   {
60946     try {
60947       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60948     } catch (std::out_of_range& e) {
60949       {
60950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60951       };
60952     } catch (std::exception& e) {
60953       {
60954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60955       };
60956     } catch (Dali::DaliException e) {
60957       {
60958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60959       };
60960     } catch (...) {
60961       {
60962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60963       };
60964     }
60965   }
60966
60967   jresult = (int)result;
60968   return jresult;
60969 }
60970
60971
60972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60973   int jresult ;
60974   int result;
60975
60976   {
60977     try {
60978       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60979     } catch (std::out_of_range& e) {
60980       {
60981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60982       };
60983     } catch (std::exception& e) {
60984       {
60985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60986       };
60987     } catch (Dali::DaliException e) {
60988       {
60989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60990       };
60991     } catch (...) {
60992       {
60993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60994       };
60995     }
60996   }
60997
60998   jresult = (int)result;
60999   return jresult;
61000 }
61001
61002
61003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61004   int jresult ;
61005   int result;
61006
61007   {
61008     try {
61009       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61010     } catch (std::out_of_range& e) {
61011       {
61012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61013       };
61014     } catch (std::exception& e) {
61015       {
61016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61017       };
61018     } catch (Dali::DaliException e) {
61019       {
61020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61021       };
61022     } catch (...) {
61023       {
61024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61025       };
61026     }
61027   }
61028
61029   jresult = (int)result;
61030   return jresult;
61031 }
61032
61033
61034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61035   int jresult ;
61036   int result;
61037
61038   {
61039     try {
61040       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61041     } catch (std::out_of_range& e) {
61042       {
61043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61044       };
61045     } catch (std::exception& e) {
61046       {
61047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61048       };
61049     } catch (Dali::DaliException e) {
61050       {
61051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61052       };
61053     } catch (...) {
61054       {
61055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61056       };
61057     }
61058   }
61059
61060   jresult = (int)result;
61061   return jresult;
61062 }
61063
61064
61065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61066   int jresult ;
61067   int result;
61068
61069   {
61070     try {
61071       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61072     } catch (std::out_of_range& e) {
61073       {
61074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61075       };
61076     } catch (std::exception& e) {
61077       {
61078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61079       };
61080     } catch (Dali::DaliException e) {
61081       {
61082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61083       };
61084     } catch (...) {
61085       {
61086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61087       };
61088     }
61089   }
61090
61091   jresult = (int)result;
61092   return jresult;
61093 }
61094
61095
61096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61097   int jresult ;
61098   int result;
61099
61100   {
61101     try {
61102       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61103     } catch (std::out_of_range& e) {
61104       {
61105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61106       };
61107     } catch (std::exception& e) {
61108       {
61109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61110       };
61111     } catch (Dali::DaliException e) {
61112       {
61113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61114       };
61115     } catch (...) {
61116       {
61117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61118       };
61119     }
61120   }
61121
61122   jresult = (int)result;
61123   return jresult;
61124 }
61125
61126
61127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61128   int jresult ;
61129   int result;
61130
61131   {
61132     try {
61133       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61134     } catch (std::out_of_range& e) {
61135       {
61136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61137       };
61138     } catch (std::exception& e) {
61139       {
61140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61141       };
61142     } catch (Dali::DaliException e) {
61143       {
61144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61145       };
61146     } catch (...) {
61147       {
61148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61149       };
61150     }
61151   }
61152
61153   jresult = (int)result;
61154   return jresult;
61155 }
61156
61157
61158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61159   void * jresult ;
61160   Dali::Toolkit::Builder *result = 0 ;
61161
61162   {
61163     try {
61164       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61165     } catch (std::out_of_range& e) {
61166       {
61167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61168       };
61169     } catch (std::exception& e) {
61170       {
61171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61172       };
61173     } catch (Dali::DaliException e) {
61174       {
61175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61176       };
61177     } catch (...) {
61178       {
61179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61180       };
61181     }
61182   }
61183
61184   jresult = (void *)result;
61185   return jresult;
61186 }
61187
61188
61189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61190   void * jresult ;
61191   Dali::Toolkit::Builder result;
61192
61193   {
61194     try {
61195       result = Dali::Toolkit::Builder::New();
61196     } catch (std::out_of_range& e) {
61197       {
61198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61199       };
61200     } catch (std::exception& e) {
61201       {
61202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61203       };
61204     } catch (Dali::DaliException e) {
61205       {
61206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61207       };
61208     } catch (...) {
61209       {
61210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61211       };
61212     }
61213   }
61214
61215   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61216   return jresult;
61217 }
61218
61219
61220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61221   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61222
61223   arg1 = (Dali::Toolkit::Builder *)jarg1;
61224   {
61225     try {
61226       delete arg1;
61227     } catch (std::out_of_range& e) {
61228       {
61229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61230       };
61231     } catch (std::exception& e) {
61232       {
61233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61234       };
61235     } catch (Dali::DaliException e) {
61236       {
61237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61238       };
61239     } catch (...) {
61240       {
61241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61242       };
61243     }
61244   }
61245
61246 }
61247
61248
61249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61250   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61251   std::string *arg2 = 0 ;
61252   Dali::Toolkit::Builder::UIFormat arg3 ;
61253
61254   arg1 = (Dali::Toolkit::Builder *)jarg1;
61255   if (!jarg2) {
61256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61257     return ;
61258   }
61259   std::string arg2_str(jarg2);
61260   arg2 = &arg2_str;
61261   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61262   {
61263     try {
61264       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61265     } catch (std::out_of_range& e) {
61266       {
61267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61268       };
61269     } catch (std::exception& e) {
61270       {
61271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61272       };
61273     } catch (Dali::DaliException e) {
61274       {
61275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61276       };
61277     } catch (...) {
61278       {
61279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61280       };
61281     }
61282   }
61283
61284
61285   //argout typemap for const std::string&
61286
61287 }
61288
61289
61290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61291   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61292   std::string *arg2 = 0 ;
61293
61294   arg1 = (Dali::Toolkit::Builder *)jarg1;
61295   if (!jarg2) {
61296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61297     return ;
61298   }
61299   std::string arg2_str(jarg2);
61300   arg2 = &arg2_str;
61301   {
61302     try {
61303       (arg1)->LoadFromString((std::string const &)*arg2);
61304     } catch (std::out_of_range& e) {
61305       {
61306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61307       };
61308     } catch (std::exception& e) {
61309       {
61310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61311       };
61312     } catch (Dali::DaliException e) {
61313       {
61314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61315       };
61316     } catch (...) {
61317       {
61318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61319       };
61320     }
61321   }
61322
61323
61324   //argout typemap for const std::string&
61325
61326 }
61327
61328
61329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61330   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61331   Dali::Property::Map *arg2 = 0 ;
61332
61333   arg1 = (Dali::Toolkit::Builder *)jarg1;
61334   arg2 = (Dali::Property::Map *)jarg2;
61335   if (!arg2) {
61336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61337     return ;
61338   }
61339   {
61340     try {
61341       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61342     } catch (std::out_of_range& e) {
61343       {
61344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61345       };
61346     } catch (std::exception& e) {
61347       {
61348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61349       };
61350     } catch (Dali::DaliException e) {
61351       {
61352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61353       };
61354     } catch (...) {
61355       {
61356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61357       };
61358     }
61359   }
61360
61361 }
61362
61363
61364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61365   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61366   std::string *arg2 = 0 ;
61367   Dali::Property::Value *arg3 = 0 ;
61368
61369   arg1 = (Dali::Toolkit::Builder *)jarg1;
61370   if (!jarg2) {
61371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61372     return ;
61373   }
61374   std::string arg2_str(jarg2);
61375   arg2 = &arg2_str;
61376   arg3 = (Dali::Property::Value *)jarg3;
61377   if (!arg3) {
61378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61379     return ;
61380   }
61381   {
61382     try {
61383       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61384     } catch (std::out_of_range& e) {
61385       {
61386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61387       };
61388     } catch (std::exception& e) {
61389       {
61390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61391       };
61392     } catch (Dali::DaliException e) {
61393       {
61394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61395       };
61396     } catch (...) {
61397       {
61398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61399       };
61400     }
61401   }
61402
61403
61404   //argout typemap for const std::string&
61405
61406 }
61407
61408
61409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61410   void * jresult ;
61411   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61412   Dali::Property::Map *result = 0 ;
61413
61414   arg1 = (Dali::Toolkit::Builder *)jarg1;
61415   {
61416     try {
61417       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61418     } catch (std::out_of_range& e) {
61419       {
61420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61421       };
61422     } catch (std::exception& e) {
61423       {
61424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61425       };
61426     } catch (Dali::DaliException e) {
61427       {
61428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61429       };
61430     } catch (...) {
61431       {
61432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61433       };
61434     }
61435   }
61436
61437   jresult = (void *)result;
61438   return jresult;
61439 }
61440
61441
61442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61443   void * jresult ;
61444   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61445   std::string *arg2 = 0 ;
61446   Dali::Property::Value *result = 0 ;
61447
61448   arg1 = (Dali::Toolkit::Builder *)jarg1;
61449   if (!jarg2) {
61450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61451     return 0;
61452   }
61453   std::string arg2_str(jarg2);
61454   arg2 = &arg2_str;
61455   {
61456     try {
61457       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61458     } catch (std::out_of_range& e) {
61459       {
61460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61461       };
61462     } catch (std::exception& e) {
61463       {
61464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61465       };
61466     } catch (Dali::DaliException e) {
61467       {
61468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61469       };
61470     } catch (...) {
61471       {
61472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61473       };
61474     }
61475   }
61476
61477   jresult = (void *)result;
61478
61479   //argout typemap for const std::string&
61480
61481   return jresult;
61482 }
61483
61484
61485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61486   void * jresult ;
61487   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61488   std::string *arg2 = 0 ;
61489   Dali::Animation result;
61490
61491   arg1 = (Dali::Toolkit::Builder *)jarg1;
61492   if (!jarg2) {
61493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61494     return 0;
61495   }
61496   std::string arg2_str(jarg2);
61497   arg2 = &arg2_str;
61498   {
61499     try {
61500       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61501     } catch (std::out_of_range& e) {
61502       {
61503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61504       };
61505     } catch (std::exception& e) {
61506       {
61507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61508       };
61509     } catch (Dali::DaliException e) {
61510       {
61511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61512       };
61513     } catch (...) {
61514       {
61515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61516       };
61517     }
61518   }
61519
61520   jresult = new Dali::Animation((const Dali::Animation &)result);
61521
61522   //argout typemap for const std::string&
61523
61524   return jresult;
61525 }
61526
61527
61528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61529   void * jresult ;
61530   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61531   std::string *arg2 = 0 ;
61532   Dali::Property::Map *arg3 = 0 ;
61533   Dali::Animation result;
61534
61535   arg1 = (Dali::Toolkit::Builder *)jarg1;
61536   if (!jarg2) {
61537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61538     return 0;
61539   }
61540   std::string arg2_str(jarg2);
61541   arg2 = &arg2_str;
61542   arg3 = (Dali::Property::Map *)jarg3;
61543   if (!arg3) {
61544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61545     return 0;
61546   }
61547   {
61548     try {
61549       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61550     } catch (std::out_of_range& e) {
61551       {
61552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61553       };
61554     } catch (std::exception& e) {
61555       {
61556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61557       };
61558     } catch (Dali::DaliException e) {
61559       {
61560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61561       };
61562     } catch (...) {
61563       {
61564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61565       };
61566     }
61567   }
61568
61569   jresult = new Dali::Animation((const Dali::Animation &)result);
61570
61571   //argout typemap for const std::string&
61572
61573   return jresult;
61574 }
61575
61576
61577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61578   void * jresult ;
61579   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61580   std::string *arg2 = 0 ;
61581   Dali::Actor arg3 ;
61582   Dali::Actor *argp3 ;
61583   Dali::Animation result;
61584
61585   arg1 = (Dali::Toolkit::Builder *)jarg1;
61586   if (!jarg2) {
61587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61588     return 0;
61589   }
61590   std::string arg2_str(jarg2);
61591   arg2 = &arg2_str;
61592   argp3 = (Dali::Actor *)jarg3;
61593   if (!argp3) {
61594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61595     return 0;
61596   }
61597   arg3 = *argp3;
61598   {
61599     try {
61600       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61601     } catch (std::out_of_range& e) {
61602       {
61603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61604       };
61605     } catch (std::exception& e) {
61606       {
61607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61608       };
61609     } catch (Dali::DaliException e) {
61610       {
61611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61612       };
61613     } catch (...) {
61614       {
61615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61616       };
61617     }
61618   }
61619
61620   jresult = new Dali::Animation((const Dali::Animation &)result);
61621
61622   //argout typemap for const std::string&
61623
61624   return jresult;
61625 }
61626
61627
61628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61629   void * jresult ;
61630   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61631   std::string *arg2 = 0 ;
61632   Dali::Property::Map *arg3 = 0 ;
61633   Dali::Actor arg4 ;
61634   Dali::Actor *argp4 ;
61635   Dali::Animation result;
61636
61637   arg1 = (Dali::Toolkit::Builder *)jarg1;
61638   if (!jarg2) {
61639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61640     return 0;
61641   }
61642   std::string arg2_str(jarg2);
61643   arg2 = &arg2_str;
61644   arg3 = (Dali::Property::Map *)jarg3;
61645   if (!arg3) {
61646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61647     return 0;
61648   }
61649   argp4 = (Dali::Actor *)jarg4;
61650   if (!argp4) {
61651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61652     return 0;
61653   }
61654   arg4 = *argp4;
61655   {
61656     try {
61657       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61658     } catch (std::out_of_range& e) {
61659       {
61660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61661       };
61662     } catch (std::exception& e) {
61663       {
61664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61665       };
61666     } catch (Dali::DaliException e) {
61667       {
61668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61669       };
61670     } catch (...) {
61671       {
61672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61673       };
61674     }
61675   }
61676
61677   jresult = new Dali::Animation((const Dali::Animation &)result);
61678
61679   //argout typemap for const std::string&
61680
61681   return jresult;
61682 }
61683
61684
61685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61686   void * jresult ;
61687   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61688   std::string *arg2 = 0 ;
61689   Dali::BaseHandle result;
61690
61691   arg1 = (Dali::Toolkit::Builder *)jarg1;
61692   if (!jarg2) {
61693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61694     return 0;
61695   }
61696   std::string arg2_str(jarg2);
61697   arg2 = &arg2_str;
61698   {
61699     try {
61700       result = (arg1)->Create((std::string const &)*arg2);
61701     } catch (std::out_of_range& e) {
61702       {
61703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61704       };
61705     } catch (std::exception& e) {
61706       {
61707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61708       };
61709     } catch (Dali::DaliException e) {
61710       {
61711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61712       };
61713     } catch (...) {
61714       {
61715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61716       };
61717     }
61718   }
61719
61720   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61721
61722   //argout typemap for const std::string&
61723
61724   return jresult;
61725 }
61726
61727
61728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61729   void * jresult ;
61730   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61731   std::string *arg2 = 0 ;
61732   Dali::Property::Map *arg3 = 0 ;
61733   Dali::BaseHandle result;
61734
61735   arg1 = (Dali::Toolkit::Builder *)jarg1;
61736   if (!jarg2) {
61737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61738     return 0;
61739   }
61740   std::string arg2_str(jarg2);
61741   arg2 = &arg2_str;
61742   arg3 = (Dali::Property::Map *)jarg3;
61743   if (!arg3) {
61744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61745     return 0;
61746   }
61747   {
61748     try {
61749       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61750     } catch (std::out_of_range& e) {
61751       {
61752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61753       };
61754     } catch (std::exception& e) {
61755       {
61756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61757       };
61758     } catch (Dali::DaliException e) {
61759       {
61760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61761       };
61762     } catch (...) {
61763       {
61764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61765       };
61766     }
61767   }
61768
61769   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61770
61771   //argout typemap for const std::string&
61772
61773   return jresult;
61774 }
61775
61776
61777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61778   void * jresult ;
61779   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61780   std::string *arg2 = 0 ;
61781   Dali::BaseHandle result;
61782
61783   arg1 = (Dali::Toolkit::Builder *)jarg1;
61784   if (!jarg2) {
61785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61786     return 0;
61787   }
61788   std::string arg2_str(jarg2);
61789   arg2 = &arg2_str;
61790   {
61791     try {
61792       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61793     } catch (std::out_of_range& e) {
61794       {
61795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61796       };
61797     } catch (std::exception& e) {
61798       {
61799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61800       };
61801     } catch (Dali::DaliException e) {
61802       {
61803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61804       };
61805     } catch (...) {
61806       {
61807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61808       };
61809     }
61810   }
61811
61812   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61813
61814   //argout typemap for const std::string&
61815
61816   return jresult;
61817 }
61818
61819
61820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61821   unsigned int jresult ;
61822   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61823   std::string *arg2 = 0 ;
61824   Dali::Handle *arg3 = 0 ;
61825   bool result;
61826
61827   arg1 = (Dali::Toolkit::Builder *)jarg1;
61828   if (!jarg2) {
61829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61830     return 0;
61831   }
61832   std::string arg2_str(jarg2);
61833   arg2 = &arg2_str;
61834   arg3 = (Dali::Handle *)jarg3;
61835   if (!arg3) {
61836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61837     return 0;
61838   }
61839   {
61840     try {
61841       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61842     } catch (std::out_of_range& e) {
61843       {
61844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61845       };
61846     } catch (std::exception& e) {
61847       {
61848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61849       };
61850     } catch (Dali::DaliException e) {
61851       {
61852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61853       };
61854     } catch (...) {
61855       {
61856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61857       };
61858     }
61859   }
61860
61861   jresult = result;
61862
61863   //argout typemap for const std::string&
61864
61865   return jresult;
61866 }
61867
61868
61869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61870   unsigned int jresult ;
61871   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61872   Dali::Handle *arg2 = 0 ;
61873   std::string *arg3 = 0 ;
61874   bool result;
61875
61876   arg1 = (Dali::Toolkit::Builder *)jarg1;
61877   arg2 = (Dali::Handle *)jarg2;
61878   if (!arg2) {
61879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61880     return 0;
61881   }
61882   if (!jarg3) {
61883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61884     return 0;
61885   }
61886   std::string arg3_str(jarg3);
61887   arg3 = &arg3_str;
61888   {
61889     try {
61890       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61891     } catch (std::out_of_range& e) {
61892       {
61893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61894       };
61895     } catch (std::exception& e) {
61896       {
61897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61898       };
61899     } catch (Dali::DaliException e) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61902       };
61903     } catch (...) {
61904       {
61905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61906       };
61907     }
61908   }
61909
61910   jresult = result;
61911
61912   //argout typemap for const std::string&
61913
61914   return jresult;
61915 }
61916
61917
61918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61919   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61920   Dali::Actor arg2 ;
61921   Dali::Actor *argp2 ;
61922
61923   arg1 = (Dali::Toolkit::Builder *)jarg1;
61924   argp2 = (Dali::Actor *)jarg2;
61925   if (!argp2) {
61926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61927     return ;
61928   }
61929   arg2 = *argp2;
61930   {
61931     try {
61932       (arg1)->AddActors(arg2);
61933     } catch (std::out_of_range& e) {
61934       {
61935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61936       };
61937     } catch (std::exception& e) {
61938       {
61939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61940       };
61941     } catch (Dali::DaliException e) {
61942       {
61943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61944       };
61945     } catch (...) {
61946       {
61947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61948       };
61949     }
61950   }
61951
61952 }
61953
61954
61955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61956   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61957   std::string *arg2 = 0 ;
61958   Dali::Actor arg3 ;
61959   Dali::Actor *argp3 ;
61960
61961   arg1 = (Dali::Toolkit::Builder *)jarg1;
61962   if (!jarg2) {
61963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61964     return ;
61965   }
61966   std::string arg2_str(jarg2);
61967   arg2 = &arg2_str;
61968   argp3 = (Dali::Actor *)jarg3;
61969   if (!argp3) {
61970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61971     return ;
61972   }
61973   arg3 = *argp3;
61974   {
61975     try {
61976       (arg1)->AddActors((std::string const &)*arg2,arg3);
61977     } catch (std::out_of_range& e) {
61978       {
61979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61980       };
61981     } catch (std::exception& e) {
61982       {
61983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61984       };
61985     } catch (Dali::DaliException e) {
61986       {
61987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61988       };
61989     } catch (...) {
61990       {
61991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61992       };
61993     }
61994   }
61995
61996
61997   //argout typemap for const std::string&
61998
61999 }
62000
62001
62002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62003   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62004   std::string *arg2 = 0 ;
62005
62006   arg1 = (Dali::Toolkit::Builder *)jarg1;
62007   if (!jarg2) {
62008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62009     return ;
62010   }
62011   std::string arg2_str(jarg2);
62012   arg2 = &arg2_str;
62013   {
62014     try {
62015       (arg1)->CreateRenderTask((std::string const &)*arg2);
62016     } catch (std::out_of_range& e) {
62017       {
62018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62019       };
62020     } catch (std::exception& e) {
62021       {
62022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62023       };
62024     } catch (Dali::DaliException e) {
62025       {
62026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62027       };
62028     } catch (...) {
62029       {
62030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62031       };
62032     }
62033   }
62034
62035
62036   //argout typemap for const std::string&
62037
62038 }
62039
62040
62041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62042   void * jresult ;
62043   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62044   std::string *arg2 = 0 ;
62045   Dali::Path result;
62046
62047   arg1 = (Dali::Toolkit::Builder *)jarg1;
62048   if (!jarg2) {
62049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62050     return 0;
62051   }
62052   std::string arg2_str(jarg2);
62053   arg2 = &arg2_str;
62054   {
62055     try {
62056       result = (arg1)->GetPath((std::string const &)*arg2);
62057     } catch (std::out_of_range& e) {
62058       {
62059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62060       };
62061     } catch (std::exception& e) {
62062       {
62063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62064       };
62065     } catch (Dali::DaliException e) {
62066       {
62067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62068       };
62069     } catch (...) {
62070       {
62071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62072       };
62073     }
62074   }
62075
62076   jresult = new Dali::Path((const Dali::Path &)result);
62077
62078   //argout typemap for const std::string&
62079
62080   return jresult;
62081 }
62082
62083
62084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62085   void * jresult ;
62086   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62087   std::string *arg2 = 0 ;
62088   Dali::PathConstrainer result;
62089
62090   arg1 = (Dali::Toolkit::Builder *)jarg1;
62091   if (!jarg2) {
62092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62093     return 0;
62094   }
62095   std::string arg2_str(jarg2);
62096   arg2 = &arg2_str;
62097   {
62098     try {
62099       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62100     } catch (std::out_of_range& e) {
62101       {
62102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62103       };
62104     } catch (std::exception& e) {
62105       {
62106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62107       };
62108     } catch (Dali::DaliException e) {
62109       {
62110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62111       };
62112     } catch (...) {
62113       {
62114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62115       };
62116     }
62117   }
62118
62119   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62120
62121   //argout typemap for const std::string&
62122
62123   return jresult;
62124 }
62125
62126
62127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62128   void * jresult ;
62129   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62130   std::string *arg2 = 0 ;
62131   Dali::LinearConstrainer result;
62132
62133   arg1 = (Dali::Toolkit::Builder *)jarg1;
62134   if (!jarg2) {
62135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62136     return 0;
62137   }
62138   std::string arg2_str(jarg2);
62139   arg2 = &arg2_str;
62140   {
62141     try {
62142       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62143     } catch (std::out_of_range& e) {
62144       {
62145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62146       };
62147     } catch (std::exception& e) {
62148       {
62149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62150       };
62151     } catch (Dali::DaliException e) {
62152       {
62153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62154       };
62155     } catch (...) {
62156       {
62157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62158       };
62159     }
62160   }
62161
62162   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62163
62164   //argout typemap for const std::string&
62165
62166   return jresult;
62167 }
62168
62169
62170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62171   void * jresult ;
62172   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62173   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62174
62175   arg1 = (Dali::Toolkit::Builder *)jarg1;
62176   {
62177     try {
62178       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62179     } catch (std::out_of_range& e) {
62180       {
62181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62182       };
62183     } catch (std::exception& e) {
62184       {
62185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62186       };
62187     } catch (Dali::DaliException e) {
62188       {
62189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62190       };
62191     } catch (...) {
62192       {
62193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62194       };
62195     }
62196   }
62197
62198   jresult = (void *)result;
62199   return jresult;
62200 }
62201
62202
62203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62204   void * jresult ;
62205   Dali::Toolkit::TransitionData *result = 0 ;
62206
62207   {
62208     try {
62209       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62210     } catch (std::out_of_range& e) {
62211       {
62212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62213       };
62214     } catch (std::exception& e) {
62215       {
62216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62217       };
62218     } catch (Dali::DaliException e) {
62219       {
62220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62221       };
62222     } catch (...) {
62223       {
62224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62225       };
62226     }
62227   }
62228
62229   jresult = (void *)result;
62230   return jresult;
62231 }
62232
62233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62234   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62235
62236   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62237   {
62238     try {
62239       delete arg1;
62240     } catch (std::out_of_range& e) {
62241       {
62242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62243       };
62244     } catch (std::exception& e) {
62245       {
62246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62247       };
62248     } catch (Dali::DaliException e) {
62249       {
62250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62251       };
62252     } catch (...) {
62253       {
62254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62255       };
62256     }
62257   }
62258
62259 }
62260
62261
62262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62263   void * jresult ;
62264   Dali::Property::Map *arg1 = 0 ;
62265   Dali::Toolkit::TransitionData result;
62266
62267   arg1 = (Dali::Property::Map *)jarg1;
62268   if (!arg1) {
62269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62270     return 0;
62271   }
62272   {
62273     try {
62274       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62275     } catch (std::out_of_range& e) {
62276       {
62277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62278       };
62279     } catch (std::exception& e) {
62280       {
62281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62282       };
62283     } catch (Dali::DaliException e) {
62284       {
62285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62286       };
62287     } catch (...) {
62288       {
62289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62290       };
62291     }
62292   }
62293
62294   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62295   return jresult;
62296 }
62297
62298
62299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62300   void * jresult ;
62301   Dali::Property::Array *arg1 = 0 ;
62302   Dali::Toolkit::TransitionData result;
62303
62304   arg1 = (Dali::Property::Array *)jarg1;
62305   if (!arg1) {
62306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62307     return 0;
62308   }
62309   {
62310     try {
62311       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62312     } catch (std::out_of_range& e) {
62313       {
62314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62315       };
62316     } catch (std::exception& e) {
62317       {
62318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62319       };
62320     } catch (Dali::DaliException e) {
62321       {
62322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62323       };
62324     } catch (...) {
62325       {
62326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62327       };
62328     }
62329   }
62330
62331   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62332   return jresult;
62333 }
62334
62335
62336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62337   void * jresult ;
62338   Dali::BaseHandle arg1 ;
62339   Dali::BaseHandle *argp1 ;
62340   Dali::Toolkit::TransitionData result;
62341
62342   argp1 = (Dali::BaseHandle *)jarg1;
62343   if (!argp1) {
62344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62345     return 0;
62346   }
62347   arg1 = *argp1;
62348   {
62349     try {
62350       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62351     } catch (std::out_of_range& e) {
62352       {
62353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62354       };
62355     } catch (std::exception& e) {
62356       {
62357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62358       };
62359     } catch (Dali::DaliException e) {
62360       {
62361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62362       };
62363     } catch (...) {
62364       {
62365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62366       };
62367     }
62368   }
62369
62370   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62371   return jresult;
62372 }
62373
62374
62375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62376   void * jresult ;
62377   Dali::Toolkit::TransitionData *arg1 = 0 ;
62378   Dali::Toolkit::TransitionData *result = 0 ;
62379
62380   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62381   if (!arg1) {
62382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62383     return 0;
62384   }
62385   {
62386     try {
62387       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62388     } catch (std::out_of_range& e) {
62389       {
62390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62391       };
62392     } catch (std::exception& e) {
62393       {
62394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62395       };
62396     } catch (Dali::DaliException e) {
62397       {
62398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62399       };
62400     } catch (...) {
62401       {
62402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62403       };
62404     }
62405   }
62406
62407   jresult = (void *)result;
62408   return jresult;
62409 }
62410
62411
62412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62413   void * jresult ;
62414   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62415   Dali::Toolkit::TransitionData *arg2 = 0 ;
62416   Dali::Toolkit::TransitionData *result = 0 ;
62417
62418   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62419   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62420   if (!arg2) {
62421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62422     return 0;
62423   }
62424   {
62425     try {
62426       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62427     } catch (std::out_of_range& e) {
62428       {
62429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62430       };
62431     } catch (std::exception& e) {
62432       {
62433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62434       };
62435     } catch (Dali::DaliException e) {
62436       {
62437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62438       };
62439     } catch (...) {
62440       {
62441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62442       };
62443     }
62444   }
62445
62446   jresult = (void *)result;
62447   return jresult;
62448 }
62449
62450
62451 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62452   unsigned long jresult ;
62453   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62454   size_t result;
62455
62456   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62457   {
62458     try {
62459       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62460     } catch (std::out_of_range& e) {
62461       {
62462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62463       };
62464     } catch (std::exception& e) {
62465       {
62466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62467       };
62468     } catch (Dali::DaliException e) {
62469       {
62470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62471       };
62472     } catch (...) {
62473       {
62474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62475       };
62476     }
62477   }
62478
62479   jresult = (unsigned long)result;
62480   return jresult;
62481 }
62482
62483
62484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62485   void * jresult ;
62486   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62487   size_t arg2 ;
62488   Dali::Property::Map result;
62489
62490   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62491   arg2 = (size_t)jarg2;
62492   {
62493     try {
62494       result = (arg1)->GetAnimatorAt(arg2);
62495     } catch (std::out_of_range& e) {
62496       {
62497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62498       };
62499     } catch (std::exception& e) {
62500       {
62501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62502       };
62503     } catch (Dali::DaliException e) {
62504       {
62505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62506       };
62507     } catch (...) {
62508       {
62509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62510       };
62511     }
62512   }
62513
62514   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62515   return jresult;
62516 }
62517
62518
62519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62520   int jresult ;
62521   int result;
62522
62523   {
62524     try {
62525       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62526     } catch (std::out_of_range& e) {
62527       {
62528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62529       };
62530     } catch (std::exception& e) {
62531       {
62532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62533       };
62534     } catch (Dali::DaliException e) {
62535       {
62536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62537       };
62538     } catch (...) {
62539       {
62540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62541       };
62542     }
62543   }
62544
62545   jresult = (int)result;
62546   return jresult;
62547 }
62548
62549
62550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62551   int jresult ;
62552   int result;
62553
62554   {
62555     try {
62556       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62557     } catch (std::out_of_range& e) {
62558       {
62559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62560       };
62561     } catch (std::exception& e) {
62562       {
62563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62564       };
62565     } catch (Dali::DaliException e) {
62566       {
62567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62568       };
62569     } catch (...) {
62570       {
62571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62572       };
62573     }
62574   }
62575
62576   jresult = (int)result;
62577   return jresult;
62578 }
62579
62580
62581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62582   int jresult ;
62583   int result;
62584
62585   {
62586     try {
62587       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62588     } catch (std::out_of_range& e) {
62589       {
62590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62591       };
62592     } catch (std::exception& e) {
62593       {
62594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62595       };
62596     } catch (Dali::DaliException e) {
62597       {
62598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62599       };
62600     } catch (...) {
62601       {
62602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62603       };
62604     }
62605   }
62606
62607   jresult = (int)result;
62608   return jresult;
62609 }
62610
62611
62612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62613   int jresult ;
62614   int result;
62615
62616   {
62617     try {
62618       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62619     } catch (std::out_of_range& e) {
62620       {
62621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62622       };
62623     } catch (std::exception& e) {
62624       {
62625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62626       };
62627     } catch (Dali::DaliException e) {
62628       {
62629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62630       };
62631     } catch (...) {
62632       {
62633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62634       };
62635     }
62636   }
62637
62638   jresult = (int)result;
62639   return jresult;
62640 }
62641
62642
62643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62644   int jresult ;
62645   int result;
62646
62647   {
62648     try {
62649       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62650     } catch (std::out_of_range& e) {
62651       {
62652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62653       };
62654     } catch (std::exception& e) {
62655       {
62656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62657       };
62658     } catch (Dali::DaliException e) {
62659       {
62660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62661       };
62662     } catch (...) {
62663       {
62664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62665       };
62666     }
62667   }
62668
62669   jresult = (int)result;
62670   return jresult;
62671 }
62672
62673
62674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62675   int jresult ;
62676   int result;
62677
62678   {
62679     try {
62680       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62681     } catch (std::out_of_range& e) {
62682       {
62683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62684       };
62685     } catch (std::exception& e) {
62686       {
62687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62688       };
62689     } catch (Dali::DaliException e) {
62690       {
62691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62692       };
62693     } catch (...) {
62694       {
62695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62696       };
62697     }
62698   }
62699
62700   jresult = (int)result;
62701   return jresult;
62702 }
62703
62704
62705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62706   int jresult ;
62707   int result;
62708
62709   {
62710     try {
62711       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62712     } catch (std::out_of_range& e) {
62713       {
62714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62715       };
62716     } catch (std::exception& e) {
62717       {
62718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62719       };
62720     } catch (Dali::DaliException e) {
62721       {
62722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62723       };
62724     } catch (...) {
62725       {
62726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62727       };
62728     }
62729   }
62730
62731   jresult = (int)result;
62732   return jresult;
62733 }
62734
62735
62736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62737   int jresult ;
62738   int result;
62739
62740   {
62741     try {
62742       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62743     } catch (std::out_of_range& e) {
62744       {
62745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62746       };
62747     } catch (std::exception& e) {
62748       {
62749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62750       };
62751     } catch (Dali::DaliException e) {
62752       {
62753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62754       };
62755     } catch (...) {
62756       {
62757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62758       };
62759     }
62760   }
62761
62762   jresult = (int)result;
62763   return jresult;
62764 }
62765
62766
62767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62768   int jresult ;
62769   int result;
62770
62771   {
62772     try {
62773       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62774     } catch (std::out_of_range& e) {
62775       {
62776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62777       };
62778     } catch (std::exception& e) {
62779       {
62780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62781       };
62782     } catch (Dali::DaliException e) {
62783       {
62784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62785       };
62786     } catch (...) {
62787       {
62788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62789       };
62790     }
62791   }
62792
62793   jresult = (int)result;
62794   return jresult;
62795 }
62796
62797
62798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62799   int jresult ;
62800   int result;
62801
62802   {
62803     try {
62804       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62805     } catch (std::out_of_range& e) {
62806       {
62807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62808       };
62809     } catch (std::exception& e) {
62810       {
62811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62812       };
62813     } catch (Dali::DaliException e) {
62814       {
62815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62816       };
62817     } catch (...) {
62818       {
62819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62820       };
62821     }
62822   }
62823
62824   jresult = (int)result;
62825   return jresult;
62826 }
62827
62828
62829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62830   int jresult ;
62831   int result;
62832
62833   {
62834     try {
62835       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62836     } catch (std::out_of_range& e) {
62837       {
62838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62839       };
62840     } catch (std::exception& e) {
62841       {
62842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62843       };
62844     } catch (Dali::DaliException e) {
62845       {
62846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62847       };
62848     } catch (...) {
62849       {
62850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62851       };
62852     }
62853   }
62854
62855   jresult = (int)result;
62856   return jresult;
62857 }
62858
62859
62860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62861   int jresult ;
62862   int result;
62863
62864   {
62865     try {
62866       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62867     } catch (std::out_of_range& e) {
62868       {
62869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62870       };
62871     } catch (std::exception& e) {
62872       {
62873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62874       };
62875     } catch (Dali::DaliException e) {
62876       {
62877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62878       };
62879     } catch (...) {
62880       {
62881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62882       };
62883     }
62884   }
62885
62886   jresult = (int)result;
62887   return jresult;
62888 }
62889
62890
62891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62892   int jresult ;
62893   int result;
62894
62895   {
62896     try {
62897       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62898     } catch (std::out_of_range& e) {
62899       {
62900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62901       };
62902     } catch (std::exception& e) {
62903       {
62904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62905       };
62906     } catch (Dali::DaliException e) {
62907       {
62908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62909       };
62910     } catch (...) {
62911       {
62912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62913       };
62914     }
62915   }
62916
62917   jresult = (int)result;
62918   return jresult;
62919 }
62920
62921
62922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62923   int jresult ;
62924   int result;
62925
62926   {
62927     try {
62928       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62929     } catch (std::out_of_range& e) {
62930       {
62931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62932       };
62933     } catch (std::exception& e) {
62934       {
62935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62936       };
62937     } catch (Dali::DaliException e) {
62938       {
62939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62940       };
62941     } catch (...) {
62942       {
62943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62944       };
62945     }
62946   }
62947
62948   jresult = (int)result;
62949   return jresult;
62950 }
62951
62952
62953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62954   void * jresult ;
62955   Dali::Toolkit::Control result;
62956
62957   {
62958     try {
62959       result = Dali::Toolkit::Internal::Control::New();
62960     } catch (std::out_of_range& e) {
62961       {
62962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62963       };
62964     } catch (std::exception& e) {
62965       {
62966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62967       };
62968     } catch (Dali::DaliException e) {
62969       {
62970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62971       };
62972     } catch (...) {
62973       {
62974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62975       };
62976     }
62977   }
62978
62979   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62980   return jresult;
62981 }
62982
62983
62984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
62985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62986   std::string *arg2 = 0 ;
62987
62988   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62989   if (!jarg2) {
62990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62991     return ;
62992   }
62993   std::string arg2_str(jarg2);
62994   arg2 = &arg2_str;
62995   {
62996     try {
62997       (arg1)->SetStyleName((std::string const &)*arg2);
62998     } catch (std::out_of_range& e) {
62999       {
63000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63001       };
63002     } catch (std::exception& e) {
63003       {
63004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63005       };
63006     } catch (Dali::DaliException e) {
63007       {
63008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63009       };
63010     } catch (...) {
63011       {
63012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63013       };
63014     }
63015   }
63016
63017
63018   //argout typemap for const std::string&
63019
63020 }
63021
63022
63023 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63024   char * jresult ;
63025   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63026   std::string *result = 0 ;
63027
63028   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63029   {
63030     try {
63031       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63032     } catch (std::out_of_range& e) {
63033       {
63034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63035       };
63036     } catch (std::exception& e) {
63037       {
63038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63039       };
63040     } catch (Dali::DaliException e) {
63041       {
63042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63043       };
63044     } catch (...) {
63045       {
63046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63047       };
63048     }
63049   }
63050
63051   jresult = SWIG_csharp_string_callback(result->c_str());
63052   return jresult;
63053 }
63054
63055
63056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63057   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63058   Dali::Vector4 *arg2 = 0 ;
63059
63060   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63061   arg2 = (Dali::Vector4 *)jarg2;
63062   if (!arg2) {
63063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63064     return ;
63065   }
63066   {
63067     try {
63068       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63069     } catch (std::out_of_range& e) {
63070       {
63071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63072       };
63073     } catch (std::exception& e) {
63074       {
63075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63076       };
63077     } catch (Dali::DaliException e) {
63078       {
63079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63080       };
63081     } catch (...) {
63082       {
63083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63084       };
63085     }
63086   }
63087
63088 }
63089
63090
63091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63092   void * jresult ;
63093   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
63094   Dali::Vector4 result;
63095
63096   arg1 = (Dali::Handle *)jarg1;
63097   {
63098     try {
63099       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
63100       if (resultMap)
63101       {
63102         if(resultMap->Find( Toolkit::Visual::Property::TYPE )->Get<int>() == Visual::COLOR )
63103         {
63104           result = resultMap->Find( ColorVisual::Property::MIX_COLOR )->Get<Vector4>();
63105         }
63106       }
63107     } catch (std::out_of_range& e) {
63108       {
63109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63110       };
63111     } catch (std::exception& e) {
63112       {
63113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63114       };
63115     } catch (Dali::DaliException e) {
63116       {
63117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63118       };
63119     } catch (...) {
63120       {
63121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63122       };
63123     }
63124   }
63125
63126   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63127   return jresult;
63128 }
63129
63130
63131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63132   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63133   Dali::Property::Map *arg2 = 0 ;
63134
63135   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63136   arg2 = (Dali::Property::Map *)jarg2;
63137   if (!arg2) {
63138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63139     return ;
63140   }
63141   {
63142     try {
63143       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63144     } catch (std::out_of_range& e) {
63145       {
63146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63147       };
63148     } catch (std::exception& e) {
63149       {
63150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63151       };
63152     } catch (Dali::DaliException e) {
63153       {
63154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63155       };
63156     } catch (...) {
63157       {
63158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63159       };
63160     }
63161   }
63162
63163 }
63164
63165
63166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63168
63169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63170   {
63171     try {
63172       (arg1)->ClearBackground();
63173     } catch (std::out_of_range& e) {
63174       {
63175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63176       };
63177     } catch (std::exception& e) {
63178       {
63179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63180       };
63181     } catch (Dali::DaliException e) {
63182       {
63183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63184       };
63185     } catch (...) {
63186       {
63187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63188       };
63189     }
63190   }
63191
63192 }
63193
63194
63195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63196   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63197   Dali::Gesture::Type arg2 ;
63198
63199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63200   arg2 = (Dali::Gesture::Type)jarg2;
63201   {
63202     try {
63203       (arg1)->EnableGestureDetection(arg2);
63204     } catch (std::out_of_range& e) {
63205       {
63206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63207       };
63208     } catch (std::exception& e) {
63209       {
63210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63211       };
63212     } catch (Dali::DaliException e) {
63213       {
63214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63215       };
63216     } catch (...) {
63217       {
63218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63219       };
63220     }
63221   }
63222
63223 }
63224
63225
63226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63227   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63228   Dali::Gesture::Type arg2 ;
63229
63230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63231   arg2 = (Dali::Gesture::Type)jarg2;
63232   {
63233     try {
63234       (arg1)->DisableGestureDetection(arg2);
63235     } catch (std::out_of_range& e) {
63236       {
63237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63238       };
63239     } catch (std::exception& e) {
63240       {
63241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63242       };
63243     } catch (Dali::DaliException e) {
63244       {
63245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63246       };
63247     } catch (...) {
63248       {
63249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63250       };
63251     }
63252   }
63253
63254 }
63255
63256
63257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63258   void * jresult ;
63259   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63260   Dali::PinchGestureDetector result;
63261
63262   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63263   {
63264     try {
63265       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
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 = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63286   return jresult;
63287 }
63288
63289
63290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63291   void * jresult ;
63292   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63293   Dali::PanGestureDetector result;
63294
63295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63296   {
63297     try {
63298       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63299     } catch (std::out_of_range& e) {
63300       {
63301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63302       };
63303     } catch (std::exception& e) {
63304       {
63305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63306       };
63307     } catch (Dali::DaliException e) {
63308       {
63309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63310       };
63311     } catch (...) {
63312       {
63313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63314       };
63315     }
63316   }
63317
63318   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63319   return jresult;
63320 }
63321
63322
63323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63324   void * jresult ;
63325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63326   Dali::TapGestureDetector result;
63327
63328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63329   {
63330     try {
63331       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63332     } catch (std::out_of_range& e) {
63333       {
63334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63335       };
63336     } catch (std::exception& e) {
63337       {
63338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63339       };
63340     } catch (Dali::DaliException e) {
63341       {
63342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63343       };
63344     } catch (...) {
63345       {
63346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63347       };
63348     }
63349   }
63350
63351   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63352   return jresult;
63353 }
63354
63355
63356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63357   void * jresult ;
63358   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63359   Dali::LongPressGestureDetector result;
63360
63361   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63362   {
63363     try {
63364       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63365     } catch (std::out_of_range& e) {
63366       {
63367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63368       };
63369     } catch (std::exception& e) {
63370       {
63371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63372       };
63373     } catch (Dali::DaliException e) {
63374       {
63375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63376       };
63377     } catch (...) {
63378       {
63379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63380       };
63381     }
63382   }
63383
63384   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63385   return jresult;
63386 }
63387
63388
63389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63390   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63391   bool arg2 ;
63392
63393   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63394   arg2 = jarg2 ? true : false;
63395   {
63396     try {
63397       (arg1)->SetKeyboardNavigationSupport(arg2);
63398     } catch (std::out_of_range& e) {
63399       {
63400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63401       };
63402     } catch (std::exception& e) {
63403       {
63404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63405       };
63406     } catch (Dali::DaliException e) {
63407       {
63408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63409       };
63410     } catch (...) {
63411       {
63412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63413       };
63414     }
63415   }
63416
63417 }
63418
63419
63420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63421   unsigned int jresult ;
63422   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63423   bool result;
63424
63425   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63426   {
63427     try {
63428       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63429     } catch (std::out_of_range& e) {
63430       {
63431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63432       };
63433     } catch (std::exception& e) {
63434       {
63435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63436       };
63437     } catch (Dali::DaliException e) {
63438       {
63439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63440       };
63441     } catch (...) {
63442       {
63443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63444       };
63445     }
63446   }
63447
63448   jresult = result;
63449   return jresult;
63450 }
63451
63452
63453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63454   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63455
63456   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63457   {
63458     try {
63459       (arg1)->SetKeyInputFocus();
63460     } catch (std::out_of_range& e) {
63461       {
63462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63463       };
63464     } catch (std::exception& e) {
63465       {
63466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63467       };
63468     } catch (Dali::DaliException e) {
63469       {
63470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63471       };
63472     } catch (...) {
63473       {
63474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63475       };
63476     }
63477   }
63478
63479 }
63480
63481
63482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63483   unsigned int jresult ;
63484   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63485   bool result;
63486
63487   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63488   {
63489     try {
63490       result = (bool)(arg1)->HasKeyInputFocus();
63491     } catch (std::out_of_range& e) {
63492       {
63493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63494       };
63495     } catch (std::exception& e) {
63496       {
63497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63498       };
63499     } catch (Dali::DaliException e) {
63500       {
63501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63502       };
63503     } catch (...) {
63504       {
63505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63506       };
63507     }
63508   }
63509
63510   jresult = result;
63511   return jresult;
63512 }
63513
63514
63515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63516   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63517
63518   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63519   {
63520     try {
63521       (arg1)->ClearKeyInputFocus();
63522     } catch (std::out_of_range& e) {
63523       {
63524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63525       };
63526     } catch (std::exception& e) {
63527       {
63528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63529       };
63530     } catch (Dali::DaliException e) {
63531       {
63532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63533       };
63534     } catch (...) {
63535       {
63536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63537       };
63538     }
63539   }
63540
63541 }
63542
63543
63544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63545   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63546   bool arg2 ;
63547
63548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63549   arg2 = jarg2 ? true : false;
63550   {
63551     try {
63552       (arg1)->SetAsKeyboardFocusGroup(arg2);
63553     } catch (std::out_of_range& e) {
63554       {
63555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63556       };
63557     } catch (std::exception& e) {
63558       {
63559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63560       };
63561     } catch (Dali::DaliException e) {
63562       {
63563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63564       };
63565     } catch (...) {
63566       {
63567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63568       };
63569     }
63570   }
63571
63572 }
63573
63574
63575 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63576   unsigned int jresult ;
63577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63578   bool result;
63579
63580   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63581   {
63582     try {
63583       result = (bool)(arg1)->IsKeyboardFocusGroup();
63584     } catch (std::out_of_range& e) {
63585       {
63586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63587       };
63588     } catch (std::exception& e) {
63589       {
63590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63591       };
63592     } catch (Dali::DaliException e) {
63593       {
63594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63595       };
63596     } catch (...) {
63597       {
63598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63599       };
63600     }
63601   }
63602
63603   jresult = result;
63604   return jresult;
63605 }
63606
63607
63608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63609   void * jresult ;
63610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63611   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63612
63613   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63614   {
63615     try {
63616       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63617     } catch (std::out_of_range& e) {
63618       {
63619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63620       };
63621     } catch (std::exception& e) {
63622       {
63623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63624       };
63625     } catch (Dali::DaliException e) {
63626       {
63627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63628       };
63629     } catch (...) {
63630       {
63631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63632       };
63633     }
63634   }
63635
63636   jresult = (void *)result;
63637   return jresult;
63638 }
63639
63640
63641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63642   void * jresult ;
63643   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63644   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63645
63646   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63647   {
63648     try {
63649       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63650     } catch (std::out_of_range& e) {
63651       {
63652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63653       };
63654     } catch (std::exception& e) {
63655       {
63656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63657       };
63658     } catch (Dali::DaliException e) {
63659       {
63660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63661       };
63662     } catch (...) {
63663       {
63664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63665       };
63666     }
63667   }
63668
63669   jresult = (void *)result;
63670   return jresult;
63671 }
63672
63673
63674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63675   void * jresult ;
63676   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63677   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63678
63679   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63680   {
63681     try {
63682       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63683     } catch (std::out_of_range& e) {
63684       {
63685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63686       };
63687     } catch (std::exception& e) {
63688       {
63689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63690       };
63691     } catch (Dali::DaliException e) {
63692       {
63693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63694       };
63695     } catch (...) {
63696       {
63697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63698       };
63699     }
63700   }
63701
63702   jresult = (void *)result;
63703   return jresult;
63704 }
63705
63706
63707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63708   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63709   int arg2 ;
63710   SwigDirector_ViewImpl *darg = 0;
63711
63712   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63713   arg2 = (int)jarg2;
63714   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63715   if(!darg) {
63716     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63717     return;
63718   }
63719   {
63720     try {
63721       if(darg) {
63722         (darg)->OnStageConnection(arg2);
63723       }
63724     } catch (std::out_of_range& e) {
63725       {
63726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63727       };
63728     } catch (std::exception& e) {
63729       {
63730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63731       };
63732     } catch (Dali::DaliException e) {
63733       {
63734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63735       };
63736     } catch (...) {
63737       {
63738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63739       };
63740     }
63741   }
63742
63743 }
63744
63745
63746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63748   int arg2 ;
63749   SwigDirector_ViewImpl *darg = 0;
63750
63751   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63752   arg2 = (int)jarg2;
63753   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63754   if(!darg) {
63755     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63756     return;
63757   }
63758   {
63759     try {
63760       if(darg) {
63761         (darg)->OnStageConnectionSwigPublic(arg2);
63762       }
63763     } catch (std::out_of_range& e) {
63764       {
63765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63766       };
63767     } catch (std::exception& e) {
63768       {
63769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63770       };
63771     } catch (Dali::DaliException e) {
63772       {
63773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63774       };
63775     } catch (...) {
63776       {
63777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63778       };
63779     }
63780   }
63781
63782 }
63783
63784
63785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63786   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63787   SwigDirector_ViewImpl *darg = 0;
63788
63789   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63790   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63791   if(!darg) {
63792     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63793     return;
63794   }
63795   {
63796     try {
63797       if(darg) {
63798         (darg)->OnStageDisconnection();
63799       }
63800     } catch (std::out_of_range& e) {
63801       {
63802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63803       };
63804     } catch (std::exception& e) {
63805       {
63806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63807       };
63808     } catch (Dali::DaliException e) {
63809       {
63810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63811       };
63812     } catch (...) {
63813       {
63814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63815       };
63816     }
63817   }
63818
63819 }
63820
63821
63822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63823   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63824   SwigDirector_ViewImpl *darg = 0;
63825
63826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63827   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63828   if(!darg) {
63829     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63830     return;
63831   }
63832   {
63833     try {
63834       if(darg) {
63835         (darg)->OnStageDisconnectionSwigPublic();
63836       }
63837     } catch (std::out_of_range& e) {
63838       {
63839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63840       };
63841     } catch (std::exception& e) {
63842       {
63843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63844       };
63845     } catch (Dali::DaliException e) {
63846       {
63847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63848       };
63849     } catch (...) {
63850       {
63851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63852       };
63853     }
63854   }
63855
63856 }
63857
63858
63859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63861   Dali::Actor *arg2 = 0 ;
63862   SwigDirector_ViewImpl *darg = 0;
63863
63864   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63865   arg2 = (Dali::Actor *)jarg2;
63866   if (!arg2) {
63867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63868     return ;
63869   }
63870   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63871   if(!darg) {
63872     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63873     return;
63874   }
63875   {
63876     try {
63877       if(darg) {
63878         (darg)->OnChildAdd(*arg2);
63879       }
63880     } catch (std::out_of_range& e) {
63881       {
63882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63883       };
63884     } catch (std::exception& e) {
63885       {
63886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63887       };
63888     } catch (Dali::DaliException e) {
63889       {
63890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63891       };
63892     } catch (...) {
63893       {
63894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63895       };
63896     }
63897   }
63898
63899 }
63900
63901
63902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63904   Dali::Actor *arg2 = 0 ;
63905   SwigDirector_ViewImpl *darg = 0;
63906
63907   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63908   arg2 = (Dali::Actor *)jarg2;
63909   if (!arg2) {
63910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63911     return ;
63912   }
63913   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63914   if(!darg) {
63915     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63916     return;
63917   }
63918   {
63919     try {
63920       if(darg) {
63921           (darg)->OnChildAddSwigPublic(*arg2);
63922       }
63923     } catch (std::out_of_range& e) {
63924       {
63925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63926       };
63927     } catch (std::exception& e) {
63928       {
63929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63930       };
63931     } catch (Dali::DaliException e) {
63932       {
63933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63934       };
63935     } catch (...) {
63936       {
63937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63938       };
63939     }
63940   }
63941
63942 }
63943
63944
63945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
63946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63947   Dali::Actor *arg2 = 0 ;
63948   SwigDirector_ViewImpl *darg = 0;
63949
63950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63951   arg2 = (Dali::Actor *)jarg2;
63952   if (!arg2) {
63953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63954     return ;
63955   }
63956   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63957   if(!darg) {
63958     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63959     return;
63960   }
63961   {
63962     try {
63963       if(darg) {
63964         (darg)->OnChildRemove(*arg2);
63965       }
63966     } catch (std::out_of_range& e) {
63967       {
63968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63969       };
63970     } catch (std::exception& e) {
63971       {
63972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63973       };
63974     } catch (Dali::DaliException e) {
63975       {
63976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63977       };
63978     } catch (...) {
63979       {
63980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63981       };
63982     }
63983   }
63984
63985 }
63986
63987
63988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63990   Dali::Actor *arg2 = 0 ;
63991   SwigDirector_ViewImpl *darg = 0;
63992
63993   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63994   arg2 = (Dali::Actor *)jarg2;
63995   if (!arg2) {
63996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63997     return ;
63998   }
63999   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64000   if(!darg) {
64001     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64002     return;
64003   }
64004   {
64005     try {
64006       if(darg) {
64007         (darg)->OnChildRemoveSwigPublic(*arg2);
64008       }
64009     } catch (std::out_of_range& e) {
64010       {
64011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64012       };
64013     } catch (std::exception& e) {
64014       {
64015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64016       };
64017     } catch (Dali::DaliException e) {
64018       {
64019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64020       };
64021     } catch (...) {
64022       {
64023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64024       };
64025     }
64026   }
64027
64028 }
64029
64030
64031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64033   Dali::Property::Index arg2 ;
64034   Dali::Property::Value arg3 ;
64035   Dali::Property::Value *argp3 ;
64036   SwigDirector_ViewImpl *darg = 0;
64037
64038   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64039   arg2 = (Dali::Property::Index)jarg2;
64040   argp3 = (Dali::Property::Value *)jarg3;
64041   if (!argp3) {
64042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64043     return ;
64044   }
64045   arg3 = *argp3;
64046   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64047   if (!darg) {
64048     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64049     return;
64050   }
64051   {
64052     try {
64053       (darg)->OnPropertySet(arg2,arg3);
64054     } catch (std::out_of_range& e) {
64055       {
64056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64057       };
64058     } catch (std::exception& e) {
64059       {
64060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64061       };
64062     } catch (Dali::DaliException e) {
64063       {
64064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64065       };
64066     } catch (...) {
64067       {
64068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64069       };
64070     }
64071   }
64072
64073 }
64074
64075
64076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64078   Dali::Property::Index arg2 ;
64079   Dali::Property::Value arg3 ;
64080   Dali::Property::Value *argp3 ;
64081   SwigDirector_ViewImpl *darg = 0;
64082
64083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64084   arg2 = (Dali::Property::Index)jarg2;
64085   argp3 = (Dali::Property::Value *)jarg3;
64086   if (!argp3) {
64087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64088     return ;
64089   }
64090   arg3 = *argp3;
64091   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64092   if (!darg) {
64093     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64094     return;
64095   }
64096   {
64097     try {
64098       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64099     } catch (std::out_of_range& e) {
64100       {
64101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64102       };
64103     } catch (std::exception& e) {
64104       {
64105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64106       };
64107     } catch (Dali::DaliException e) {
64108       {
64109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64110       };
64111     } catch (...) {
64112       {
64113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64114       };
64115     }
64116   }
64117
64118 }
64119
64120
64121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64123   Dali::Vector3 *arg2 = 0 ;
64124   SwigDirector_ViewImpl *darg = 0;
64125
64126   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64127   arg2 = (Dali::Vector3 *)jarg2;
64128   if (!arg2) {
64129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64130     return ;
64131   }
64132   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64133   if (!darg) {
64134     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64135     return;
64136   }
64137   {
64138     try {
64139       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64140     } catch (std::out_of_range& e) {
64141       {
64142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64143       };
64144     } catch (std::exception& e) {
64145       {
64146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64147       };
64148     } catch (Dali::DaliException e) {
64149       {
64150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64151       };
64152     } catch (...) {
64153       {
64154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64155       };
64156     }
64157   }
64158
64159 }
64160
64161
64162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64163   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64164   Dali::Vector3 *arg2 = 0 ;
64165   SwigDirector_ViewImpl *darg = 0;
64166
64167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64168   arg2 = (Dali::Vector3 *)jarg2;
64169   if (!arg2) {
64170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64171     return ;
64172   }
64173   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64174   if (!darg) {
64175     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64176     return;
64177   }
64178   {
64179     try {
64180       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64181     } catch (std::out_of_range& e) {
64182       {
64183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64184       };
64185     } catch (std::exception& e) {
64186       {
64187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64188       };
64189     } catch (Dali::DaliException e) {
64190       {
64191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64192       };
64193     } catch (...) {
64194       {
64195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64196       };
64197     }
64198   }
64199
64200 }
64201
64202
64203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64205   Dali::Animation *arg2 = 0 ;
64206   Dali::Vector3 *arg3 = 0 ;
64207   SwigDirector_ViewImpl *darg = 0;
64208
64209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64210   arg2 = (Dali::Animation *)jarg2;
64211   if (!arg2) {
64212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64213     return ;
64214   }
64215   arg3 = (Dali::Vector3 *)jarg3;
64216   if (!arg3) {
64217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64218     return ;
64219   }
64220   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64221   if (!darg) {
64222     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64223     return;
64224   }
64225   {
64226     try {
64227       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64228     } catch (std::out_of_range& e) {
64229       {
64230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64231       };
64232     } catch (std::exception& e) {
64233       {
64234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64235       };
64236     } catch (Dali::DaliException e) {
64237       {
64238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64239       };
64240     } catch (...) {
64241       {
64242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64243       };
64244     }
64245   }
64246
64247 }
64248
64249
64250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64251   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64252   Dali::Animation *arg2 = 0 ;
64253   Dali::Vector3 *arg3 = 0 ;
64254   SwigDirector_ViewImpl *darg = 0;
64255
64256   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64257   arg2 = (Dali::Animation *)jarg2;
64258   if (!arg2) {
64259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64260     return ;
64261   }
64262   arg3 = (Dali::Vector3 *)jarg3;
64263   if (!arg3) {
64264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64265     return ;
64266   }
64267   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64268   if (!darg) {
64269     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64270     return;
64271   }
64272   {
64273     try {
64274       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64275     } catch (std::out_of_range& e) {
64276       {
64277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64278       };
64279     } catch (std::exception& e) {
64280       {
64281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64282       };
64283     } catch (Dali::DaliException e) {
64284       {
64285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64286       };
64287     } catch (...) {
64288       {
64289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64290       };
64291     }
64292   }
64293
64294 }
64295
64296
64297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64298   unsigned int jresult ;
64299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64300   Dali::TouchEvent *arg2 = 0 ;
64301   SwigDirector_ViewImpl *darg = 0;
64302   bool result;
64303
64304   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64305   arg2 = (Dali::TouchEvent *)jarg2;
64306   if (!arg2) {
64307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64308     return 0;
64309   }
64310   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64311   if (!darg) {
64312     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64313     return 0;
64314   }
64315   {
64316     try {
64317       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64318     } catch (std::out_of_range& e) {
64319       {
64320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64321       };
64322     } catch (std::exception& e) {
64323       {
64324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64325       };
64326     } catch (Dali::DaliException e) {
64327       {
64328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64329       };
64330     } catch (...) {
64331       {
64332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64333       };
64334     }
64335   }
64336
64337   jresult = result;
64338   return jresult;
64339 }
64340
64341
64342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64343   unsigned int jresult ;
64344   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64345   Dali::TouchEvent *arg2 = 0 ;
64346   SwigDirector_ViewImpl *darg = 0;
64347   bool result;
64348
64349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64350   arg2 = (Dali::TouchEvent *)jarg2;
64351   if (!arg2) {
64352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64353     return 0;
64354   }
64355   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64356   if (!darg) {
64357     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64358     return 0;
64359   }
64360   {
64361     try {
64362       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64363     } catch (std::out_of_range& e) {
64364       {
64365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64366       };
64367     } catch (std::exception& e) {
64368       {
64369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64370       };
64371     } catch (Dali::DaliException e) {
64372       {
64373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64374       };
64375     } catch (...) {
64376       {
64377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64378       };
64379     }
64380   }
64381
64382   jresult = result;
64383   return jresult;
64384 }
64385
64386
64387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64388   unsigned int jresult ;
64389   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64390   Dali::HoverEvent *arg2 = 0 ;
64391   SwigDirector_ViewImpl *darg = 0;
64392   bool result;
64393
64394   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64395   arg2 = (Dali::HoverEvent *)jarg2;
64396   if (!arg2) {
64397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64398     return 0;
64399   }
64400   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64401   if (!darg) {
64402     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64403     return 0;
64404   }
64405   {
64406     try {
64407       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64408     } catch (std::out_of_range& e) {
64409       {
64410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64411       };
64412     } catch (std::exception& e) {
64413       {
64414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64415       };
64416     } catch (Dali::DaliException e) {
64417       {
64418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64419       };
64420     } catch (...) {
64421       {
64422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64423       };
64424     }
64425   }
64426
64427   jresult = result;
64428   return jresult;
64429 }
64430
64431
64432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64433   unsigned int jresult ;
64434   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64435   Dali::HoverEvent *arg2 = 0 ;
64436   SwigDirector_ViewImpl *darg = 0;
64437   bool result;
64438
64439   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64440   arg2 = (Dali::HoverEvent *)jarg2;
64441   if (!arg2) {
64442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64443     return 0;
64444   }
64445   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64446   if (!darg) {
64447     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64448     return 0;
64449   }
64450   {
64451     try {
64452       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64453     } catch (std::out_of_range& e) {
64454       {
64455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64456       };
64457     } catch (std::exception& e) {
64458       {
64459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64460       };
64461     } catch (Dali::DaliException e) {
64462       {
64463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64464       };
64465     } catch (...) {
64466       {
64467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64468       };
64469     }
64470   }
64471
64472   jresult = result;
64473   return jresult;
64474 }
64475
64476
64477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64478   unsigned int jresult ;
64479   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64480   Dali::KeyEvent *arg2 = 0 ;
64481   SwigDirector_ViewImpl *darg = 0;
64482   bool result;
64483
64484   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64485   arg2 = (Dali::KeyEvent *)jarg2;
64486   if (!arg2) {
64487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64488     return 0;
64489   }
64490   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64491   if (!darg) {
64492     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64493     return 0;
64494   }
64495   {
64496     try {
64497       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64498     } catch (std::out_of_range& e) {
64499       {
64500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64501       };
64502     } catch (std::exception& e) {
64503       {
64504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64505       };
64506     } catch (Dali::DaliException e) {
64507       {
64508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64509       };
64510     } catch (...) {
64511       {
64512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64513       };
64514     }
64515   }
64516
64517   jresult = result;
64518   return jresult;
64519 }
64520
64521
64522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64523   unsigned int jresult ;
64524   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64525   Dali::KeyEvent *arg2 = 0 ;
64526   SwigDirector_ViewImpl *darg = 0;
64527   bool result;
64528
64529   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64530   arg2 = (Dali::KeyEvent *)jarg2;
64531   if (!arg2) {
64532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64533     return 0;
64534   }
64535   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64536   if (!darg) {
64537     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64538     return 0;
64539   }
64540   {
64541     try {
64542       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64543     } catch (std::out_of_range& e) {
64544       {
64545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64546       };
64547     } catch (std::exception& e) {
64548       {
64549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64550       };
64551     } catch (Dali::DaliException e) {
64552       {
64553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64554       };
64555     } catch (...) {
64556       {
64557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64558       };
64559     }
64560   }
64561
64562   jresult = result;
64563   return jresult;
64564 }
64565
64566
64567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64568   unsigned int jresult ;
64569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64570   Dali::WheelEvent *arg2 = 0 ;
64571   SwigDirector_ViewImpl *darg = 0;
64572   bool result;
64573
64574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64575   arg2 = (Dali::WheelEvent *)jarg2;
64576   if (!arg2) {
64577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64578     return 0;
64579   }
64580   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64581   if (!darg) {
64582     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64583     return 0;
64584   }
64585   {
64586     try {
64587       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64588     } catch (std::out_of_range& e) {
64589       {
64590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64591       };
64592     } catch (std::exception& e) {
64593       {
64594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64595       };
64596     } catch (Dali::DaliException e) {
64597       {
64598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64599       };
64600     } catch (...) {
64601       {
64602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64603       };
64604     }
64605   }
64606
64607   jresult = result;
64608   return jresult;
64609 }
64610
64611
64612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64613   unsigned int jresult ;
64614   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64615   Dali::WheelEvent *arg2 = 0 ;
64616   SwigDirector_ViewImpl *darg = 0;
64617   bool result;
64618
64619   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64620   arg2 = (Dali::WheelEvent *)jarg2;
64621   if (!arg2) {
64622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64623     return 0;
64624   }
64625   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64626   if (!darg) {
64627     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64628     return 0;
64629   }
64630   {
64631     try {
64632       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64633     } catch (std::out_of_range& e) {
64634       {
64635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64636       };
64637     } catch (std::exception& e) {
64638       {
64639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64640       };
64641     } catch (Dali::DaliException e) {
64642       {
64643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64644       };
64645     } catch (...) {
64646       {
64647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64648       };
64649     }
64650   }
64651
64652   jresult = result;
64653   return jresult;
64654 }
64655
64656
64657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64658   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64659   Dali::Vector2 *arg2 = 0 ;
64660   Dali::RelayoutContainer *arg3 = 0 ;
64661   SwigDirector_ViewImpl *darg = 0;
64662
64663   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64664   arg2 = (Dali::Vector2 *)jarg2;
64665   if (!arg2) {
64666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64667     return ;
64668   }
64669   arg3 = (Dali::RelayoutContainer *)jarg3;
64670   if (!arg3) {
64671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64672     return ;
64673   }
64674   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64675   if (!darg) {
64676     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64677     return;
64678   }
64679   {
64680     try {
64681       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64682     } catch (std::out_of_range& e) {
64683       {
64684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64685       };
64686     } catch (std::exception& e) {
64687       {
64688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64689       };
64690     } catch (Dali::DaliException e) {
64691       {
64692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64693       };
64694     } catch (...) {
64695       {
64696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64697       };
64698     }
64699   }
64700
64701 }
64702
64703
64704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64706   Dali::Vector2 *arg2 = 0 ;
64707   Dali::RelayoutContainer *arg3 = 0 ;
64708   SwigDirector_ViewImpl *darg = 0;
64709
64710   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64711   arg2 = (Dali::Vector2 *)jarg2;
64712   if (!arg2) {
64713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64714     return ;
64715   }
64716   arg3 = (Dali::RelayoutContainer *)jarg3;
64717   if (!arg3) {
64718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64719     return ;
64720   }
64721   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64722   if (!darg) {
64723     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64724     return;
64725   }
64726   {
64727     try {
64728       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64729     } catch (std::out_of_range& e) {
64730       {
64731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64732       };
64733     } catch (std::exception& e) {
64734       {
64735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64736       };
64737     } catch (Dali::DaliException e) {
64738       {
64739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64740       };
64741     } catch (...) {
64742       {
64743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64744       };
64745     }
64746   }
64747
64748 }
64749
64750
64751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64752   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64753   Dali::ResizePolicy::Type arg2 ;
64754   Dali::Dimension::Type arg3 ;
64755   SwigDirector_ViewImpl *darg = 0;
64756
64757   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64758   arg2 = (Dali::ResizePolicy::Type)jarg2;
64759   arg3 = (Dali::Dimension::Type)jarg3;
64760   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64761   if (!darg) {
64762     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64763     return;
64764   }
64765   {
64766     try {
64767       (darg)->OnSetResizePolicy(arg2,arg3);
64768     } catch (std::out_of_range& e) {
64769       {
64770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64771       };
64772     } catch (std::exception& e) {
64773       {
64774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64775       };
64776     } catch (Dali::DaliException e) {
64777       {
64778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64779       };
64780     } catch (...) {
64781       {
64782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64783       };
64784     }
64785   }
64786
64787 }
64788
64789
64790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64791   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64792   Dali::ResizePolicy::Type arg2 ;
64793   Dali::Dimension::Type arg3 ;
64794   SwigDirector_ViewImpl *darg = 0;
64795
64796   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64797   arg2 = (Dali::ResizePolicy::Type)jarg2;
64798   arg3 = (Dali::Dimension::Type)jarg3;
64799   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64800   if (!darg) {
64801     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64802     return;
64803   }
64804   {
64805     try {
64806       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64807     } catch (std::out_of_range& e) {
64808       {
64809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64810       };
64811     } catch (std::exception& e) {
64812       {
64813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64814       };
64815     } catch (Dali::DaliException e) {
64816       {
64817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64818       };
64819     } catch (...) {
64820       {
64821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64822       };
64823     }
64824   }
64825
64826 }
64827
64828
64829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64830   void * jresult ;
64831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64832   SwigDirector_ViewImpl *darg = 0;
64833   Dali::Vector3 result;
64834
64835   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64836   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64837   if (!darg) {
64838     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64839     return 0;
64840   }
64841   {
64842     try {
64843       result = (darg)->GetNaturalSize();
64844     } catch (std::out_of_range& e) {
64845       {
64846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64847       };
64848     } catch (std::exception& e) {
64849       {
64850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64851       };
64852     } catch (Dali::DaliException e) {
64853       {
64854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64855       };
64856     } catch (...) {
64857       {
64858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64859       };
64860     }
64861   }
64862
64863   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64864   return jresult;
64865 }
64866
64867
64868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64869   void * jresult ;
64870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64871   SwigDirector_ViewImpl *darg = 0;
64872   Dali::Vector3 result;
64873
64874   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64875   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64876   if (!darg) {
64877     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64878     return 0;
64879   }
64880   {
64881     try {
64882       result = (darg)->GetNaturalSizeSwigPublic();
64883     } catch (std::out_of_range& e) {
64884       {
64885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64886       };
64887     } catch (std::exception& e) {
64888       {
64889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64890       };
64891     } catch (Dali::DaliException e) {
64892       {
64893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64894       };
64895     } catch (...) {
64896       {
64897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64898       };
64899     }
64900   }
64901
64902   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64903   return jresult;
64904 }
64905
64906
64907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64908   float jresult ;
64909   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64910   Dali::Actor *arg2 = 0 ;
64911   Dali::Dimension::Type arg3 ;
64912   SwigDirector_ViewImpl *darg = 0;
64913   float result;
64914
64915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64916   arg2 = (Dali::Actor *)jarg2;
64917   if (!arg2) {
64918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64919     return 0;
64920   }
64921   arg3 = (Dali::Dimension::Type)jarg3;
64922   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64923   if (!darg) {
64924     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64925     return 0;
64926   }
64927   {
64928     try {
64929       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
64930     } catch (std::out_of_range& e) {
64931       {
64932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64933       };
64934     } catch (std::exception& e) {
64935       {
64936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64937       };
64938     } catch (Dali::DaliException e) {
64939       {
64940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64941       };
64942     } catch (...) {
64943       {
64944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64945       };
64946     }
64947   }
64948
64949   jresult = result;
64950   return jresult;
64951 }
64952
64953
64954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64955   float jresult ;
64956   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64957   Dali::Actor *arg2 = 0 ;
64958   Dali::Dimension::Type arg3 ;
64959   SwigDirector_ViewImpl *darg = 0;
64960   float result;
64961
64962   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64963   arg2 = (Dali::Actor *)jarg2;
64964   if (!arg2) {
64965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64966     return 0;
64967   }
64968   arg3 = (Dali::Dimension::Type)jarg3;
64969   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64970   if (!darg) {
64971     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64972     return 0;
64973   }
64974   {
64975     try {
64976       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
64977     } catch (std::out_of_range& e) {
64978       {
64979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64980       };
64981     } catch (std::exception& e) {
64982       {
64983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64984       };
64985     } catch (Dali::DaliException e) {
64986       {
64987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64988       };
64989     } catch (...) {
64990       {
64991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64992       };
64993     }
64994   }
64995
64996   jresult = result;
64997   return jresult;
64998 }
64999
65000
65001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65002   float jresult ;
65003   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65004   float arg2 ;
65005   SwigDirector_ViewImpl *darg = 0;
65006   float result;
65007
65008   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65009   arg2 = (float)jarg2;
65010   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65011   if (!darg) {
65012     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65013     return 0;
65014   }
65015   {
65016     try {
65017       result = (float)(darg)->GetHeightForWidth(arg2);
65018     } catch (std::out_of_range& e) {
65019       {
65020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65021       };
65022     } catch (std::exception& e) {
65023       {
65024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65025       };
65026     } catch (Dali::DaliException e) {
65027       {
65028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65029       };
65030     } catch (...) {
65031       {
65032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65033       };
65034     }
65035   }
65036
65037   jresult = result;
65038   return jresult;
65039 }
65040
65041
65042 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65043   float jresult ;
65044   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65045   float arg2 ;
65046   SwigDirector_ViewImpl *darg = 0;
65047   float result;
65048
65049   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65050   arg2 = (float)jarg2;
65051   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65052   if (!darg) {
65053     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65054     return 0;
65055   }
65056   {
65057     try {
65058       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65059     } catch (std::out_of_range& e) {
65060       {
65061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65062       };
65063     } catch (std::exception& e) {
65064       {
65065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65066       };
65067     } catch (Dali::DaliException e) {
65068       {
65069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65070       };
65071     } catch (...) {
65072       {
65073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65074       };
65075     }
65076   }
65077
65078   jresult = result;
65079   return jresult;
65080 }
65081
65082
65083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65084   float jresult ;
65085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65086   float arg2 ;
65087   SwigDirector_ViewImpl *darg = 0;
65088   float result;
65089
65090   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65091   arg2 = (float)jarg2;
65092   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65093   if (!darg) {
65094     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65095     return 0;
65096   }
65097   {
65098     try {
65099       result = (float)(darg)->GetWidthForHeight(arg2);
65100     } catch (std::out_of_range& e) {
65101       {
65102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65103       };
65104     } catch (std::exception& e) {
65105       {
65106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65107       };
65108     } catch (Dali::DaliException e) {
65109       {
65110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65111       };
65112     } catch (...) {
65113       {
65114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65115       };
65116     }
65117   }
65118
65119   jresult = result;
65120   return jresult;
65121 }
65122
65123
65124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65125   float jresult ;
65126   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65127   float arg2 ;
65128   SwigDirector_ViewImpl *darg = 0;
65129   float result;
65130
65131   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65132   arg2 = (float)jarg2;
65133   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65134   if (!darg) {
65135     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65136     return 0;
65137   }
65138   {
65139     try {
65140       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65141     } catch (std::out_of_range& e) {
65142       {
65143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65144       };
65145     } catch (std::exception& e) {
65146       {
65147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65148       };
65149     } catch (Dali::DaliException e) {
65150       {
65151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65152       };
65153     } catch (...) {
65154       {
65155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65156       };
65157     }
65158   }
65159
65160   jresult = result;
65161   return jresult;
65162 }
65163
65164
65165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65166   unsigned int jresult ;
65167   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65168   Dali::Dimension::Type arg2 ;
65169   SwigDirector_ViewImpl *darg = 0;
65170   bool result;
65171
65172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65173   arg2 = (Dali::Dimension::Type)jarg2;
65174   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65175   if (!darg) {
65176     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65177     return 0;
65178   }
65179   {
65180     try {
65181       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65182     } catch (std::out_of_range& e) {
65183       {
65184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65185       };
65186     } catch (std::exception& e) {
65187       {
65188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65189       };
65190     } catch (Dali::DaliException e) {
65191       {
65192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65193       };
65194     } catch (...) {
65195       {
65196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65197       };
65198     }
65199   }
65200
65201   jresult = result;
65202   return jresult;
65203 }
65204
65205
65206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65207   unsigned int jresult ;
65208   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65209   Dali::Dimension::Type arg2 ;
65210   SwigDirector_ViewImpl *darg = 0;
65211   bool result;
65212
65213   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65214   arg2 = (Dali::Dimension::Type)jarg2;
65215   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65216   if (!darg) {
65217     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65218     return 0;
65219   }
65220   {
65221     try {
65222       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65223     } catch (std::out_of_range& e) {
65224       {
65225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65226       };
65227     } catch (std::exception& e) {
65228       {
65229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65230       };
65231     } catch (Dali::DaliException e) {
65232       {
65233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65234       };
65235     } catch (...) {
65236       {
65237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65238       };
65239     }
65240   }
65241
65242   jresult = result;
65243   return jresult;
65244 }
65245
65246
65247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65248   unsigned int jresult ;
65249   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65250   SwigDirector_ViewImpl *darg = 0;
65251   bool result;
65252
65253   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65254   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65255   if (!darg) {
65256     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65257     return 0;
65258   }
65259   {
65260     try {
65261       result = (bool)(darg)->RelayoutDependentOnChildren();
65262     } catch (std::out_of_range& e) {
65263       {
65264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65265       };
65266     } catch (std::exception& e) {
65267       {
65268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65269       };
65270     } catch (Dali::DaliException e) {
65271       {
65272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65273       };
65274     } catch (...) {
65275       {
65276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65277       };
65278     }
65279   }
65280
65281   jresult = result;
65282   return jresult;
65283 }
65284
65285
65286 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65287   unsigned int jresult ;
65288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65289   SwigDirector_ViewImpl *darg = 0;
65290   bool result;
65291
65292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65293   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65294   if (!darg) {
65295     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65296     return 0;
65297   }
65298   {
65299     try {
65300       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65301     } catch (std::out_of_range& e) {
65302       {
65303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65304       };
65305     } catch (std::exception& e) {
65306       {
65307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65308       };
65309     } catch (Dali::DaliException e) {
65310       {
65311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65312       };
65313     } catch (...) {
65314       {
65315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65316       };
65317     }
65318   }
65319
65320   jresult = result;
65321   return jresult;
65322 }
65323
65324
65325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65326   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65327   Dali::Dimension::Type arg2 ;
65328   SwigDirector_ViewImpl *darg = 0;
65329
65330   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65331   arg2 = (Dali::Dimension::Type)jarg2;
65332   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65333   if (!darg) {
65334     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65335     return;
65336   }
65337   {
65338     try {
65339       (darg)->OnCalculateRelayoutSize(arg2);
65340     } catch (std::out_of_range& e) {
65341       {
65342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65343       };
65344     } catch (std::exception& e) {
65345       {
65346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65347       };
65348     } catch (Dali::DaliException e) {
65349       {
65350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65351       };
65352     } catch (...) {
65353       {
65354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65355       };
65356     }
65357   }
65358
65359 }
65360
65361
65362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65364   Dali::Dimension::Type arg2 ;
65365   SwigDirector_ViewImpl *darg = 0;
65366
65367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65368   arg2 = (Dali::Dimension::Type)jarg2;
65369   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65370   if (!darg) {
65371     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65372     return;
65373   }
65374   {
65375     try {
65376       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65377     } catch (std::out_of_range& e) {
65378       {
65379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65380       };
65381     } catch (std::exception& e) {
65382       {
65383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65384       };
65385     } catch (Dali::DaliException e) {
65386       {
65387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65388       };
65389     } catch (...) {
65390       {
65391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65392       };
65393     }
65394   }
65395
65396 }
65397
65398
65399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65401   float arg2 ;
65402   Dali::Dimension::Type arg3 ;
65403   SwigDirector_ViewImpl *darg = 0;
65404
65405   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65406   arg2 = (float)jarg2;
65407   arg3 = (Dali::Dimension::Type)jarg3;
65408   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65409   if (!darg) {
65410     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65411     return;
65412   }
65413   {
65414     try {
65415       (darg)->OnLayoutNegotiated(arg2,arg3);
65416     } catch (std::out_of_range& e) {
65417       {
65418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65419       };
65420     } catch (std::exception& e) {
65421       {
65422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65423       };
65424     } catch (Dali::DaliException e) {
65425       {
65426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65427       };
65428     } catch (...) {
65429       {
65430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65431       };
65432     }
65433   }
65434
65435 }
65436
65437
65438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65439   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65440   float arg2 ;
65441   Dali::Dimension::Type arg3 ;
65442   SwigDirector_ViewImpl *darg = 0;
65443
65444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65445   arg2 = (float)jarg2;
65446   arg3 = (Dali::Dimension::Type)jarg3;
65447   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65448   if (!darg) {
65449     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65450     return;
65451   }
65452   {
65453     try {
65454       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65455     } catch (std::out_of_range& e) {
65456       {
65457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65458       };
65459     } catch (std::exception& e) {
65460       {
65461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65462       };
65463     } catch (Dali::DaliException e) {
65464       {
65465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65466       };
65467     } catch (...) {
65468       {
65469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65470       };
65471     }
65472   }
65473
65474 }
65475
65476
65477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65478   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65479
65480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65481   {
65482     try {
65483       (arg1)->OnInitialize();
65484     } catch (std::out_of_range& e) {
65485       {
65486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65487       };
65488     } catch (std::exception& e) {
65489       {
65490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65491       };
65492     } catch (Dali::DaliException e) {
65493       {
65494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65495       };
65496     } catch (...) {
65497       {
65498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65499       };
65500     }
65501   }
65502
65503 }
65504
65505
65506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65507   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65508
65509   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65510   {
65511     try {
65512       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65513     } catch (std::out_of_range& e) {
65514       {
65515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65516       };
65517     } catch (std::exception& e) {
65518       {
65519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65520       };
65521     } catch (Dali::DaliException e) {
65522       {
65523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65524       };
65525     } catch (...) {
65526       {
65527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65528       };
65529     }
65530   }
65531
65532 }
65533
65534
65535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65537   Dali::Actor *arg2 = 0 ;
65538
65539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65540   arg2 = (Dali::Actor *)jarg2;
65541   if (!arg2) {
65542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65543     return ;
65544   }
65545   {
65546     try {
65547       (arg1)->OnControlChildAdd(*arg2);
65548     } catch (std::out_of_range& e) {
65549       {
65550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65551       };
65552     } catch (std::exception& e) {
65553       {
65554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65555       };
65556     } catch (Dali::DaliException e) {
65557       {
65558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65559       };
65560     } catch (...) {
65561       {
65562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65563       };
65564     }
65565   }
65566
65567 }
65568
65569
65570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65571   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65572   Dali::Actor *arg2 = 0 ;
65573
65574   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65575   arg2 = (Dali::Actor *)jarg2;
65576   if (!arg2) {
65577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65578     return ;
65579   }
65580   {
65581     try {
65582       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65583     } catch (std::out_of_range& e) {
65584       {
65585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65586       };
65587     } catch (std::exception& e) {
65588       {
65589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65590       };
65591     } catch (Dali::DaliException e) {
65592       {
65593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65594       };
65595     } catch (...) {
65596       {
65597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65598       };
65599     }
65600   }
65601
65602 }
65603
65604
65605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65606   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65607   Dali::Actor *arg2 = 0 ;
65608
65609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65610   arg2 = (Dali::Actor *)jarg2;
65611   if (!arg2) {
65612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65613     return ;
65614   }
65615   {
65616     try {
65617       (arg1)->OnControlChildRemove(*arg2);
65618     } catch (std::out_of_range& e) {
65619       {
65620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65621       };
65622     } catch (std::exception& e) {
65623       {
65624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65625       };
65626     } catch (Dali::DaliException e) {
65627       {
65628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65629       };
65630     } catch (...) {
65631       {
65632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65633       };
65634     }
65635   }
65636
65637 }
65638
65639
65640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65642   Dali::Actor *arg2 = 0 ;
65643
65644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65645   arg2 = (Dali::Actor *)jarg2;
65646   if (!arg2) {
65647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65648     return ;
65649   }
65650   {
65651     try {
65652       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65653     } catch (std::out_of_range& e) {
65654       {
65655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65656       };
65657     } catch (std::exception& e) {
65658       {
65659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65660       };
65661     } catch (Dali::DaliException e) {
65662       {
65663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65664       };
65665     } catch (...) {
65666       {
65667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65668       };
65669     }
65670   }
65671
65672 }
65673
65674
65675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65676   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65677   Dali::Toolkit::StyleManager arg2 ;
65678   Dali::StyleChange::Type arg3 ;
65679   Dali::Toolkit::StyleManager *argp2 ;
65680
65681   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65682   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65683   if (!argp2) {
65684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65685     return ;
65686   }
65687   arg2 = *argp2;
65688   arg3 = (Dali::StyleChange::Type)jarg3;
65689   {
65690     try {
65691       (arg1)->OnStyleChange(arg2,arg3);
65692     } catch (std::out_of_range& e) {
65693       {
65694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65695       };
65696     } catch (std::exception& e) {
65697       {
65698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65699       };
65700     } catch (Dali::DaliException e) {
65701       {
65702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65703       };
65704     } catch (...) {
65705       {
65706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65707       };
65708     }
65709   }
65710
65711 }
65712
65713
65714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65716   Dali::Toolkit::StyleManager arg2 ;
65717   Dali::StyleChange::Type arg3 ;
65718   Dali::Toolkit::StyleManager *argp2 ;
65719
65720   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65721   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65722   if (!argp2) {
65723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65724     return ;
65725   }
65726   arg2 = *argp2;
65727   arg3 = (Dali::StyleChange::Type)jarg3;
65728   {
65729     try {
65730       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65731     } catch (std::out_of_range& e) {
65732       {
65733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65734       };
65735     } catch (std::exception& e) {
65736       {
65737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65738       };
65739     } catch (Dali::DaliException e) {
65740       {
65741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65742       };
65743     } catch (...) {
65744       {
65745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65746       };
65747     }
65748   }
65749
65750 }
65751
65752
65753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65754   unsigned int jresult ;
65755   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65756   bool result;
65757
65758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65759   {
65760     try {
65761       result = (bool)(arg1)->OnAccessibilityActivated();
65762     } catch (std::out_of_range& e) {
65763       {
65764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65765       };
65766     } catch (std::exception& e) {
65767       {
65768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65769       };
65770     } catch (Dali::DaliException e) {
65771       {
65772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65773       };
65774     } catch (...) {
65775       {
65776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65777       };
65778     }
65779   }
65780
65781   jresult = result;
65782   return jresult;
65783 }
65784
65785
65786 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65787   unsigned int jresult ;
65788   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65789   bool result;
65790
65791   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65792   {
65793     try {
65794       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65795     } catch (std::out_of_range& e) {
65796       {
65797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65798       };
65799     } catch (std::exception& e) {
65800       {
65801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65802       };
65803     } catch (Dali::DaliException e) {
65804       {
65805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65806       };
65807     } catch (...) {
65808       {
65809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65810       };
65811     }
65812   }
65813
65814   jresult = result;
65815   return jresult;
65816 }
65817
65818
65819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65820   unsigned int jresult ;
65821   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65822   Dali::PanGesture arg2 ;
65823   Dali::PanGesture *argp2 ;
65824   bool result;
65825
65826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65827   argp2 = (Dali::PanGesture *)jarg2;
65828   if (!argp2) {
65829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65830     return 0;
65831   }
65832   arg2 = *argp2;
65833   {
65834     try {
65835       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65836     } catch (std::out_of_range& e) {
65837       {
65838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65839       };
65840     } catch (std::exception& e) {
65841       {
65842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65843       };
65844     } catch (Dali::DaliException e) {
65845       {
65846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65847       };
65848     } catch (...) {
65849       {
65850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65851       };
65852     }
65853   }
65854
65855   jresult = result;
65856   return jresult;
65857 }
65858
65859
65860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65861   unsigned int jresult ;
65862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65863   Dali::PanGesture arg2 ;
65864   Dali::PanGesture *argp2 ;
65865   bool result;
65866
65867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65868   argp2 = (Dali::PanGesture *)jarg2;
65869   if (!argp2) {
65870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65871     return 0;
65872   }
65873   arg2 = *argp2;
65874   {
65875     try {
65876       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65877     } catch (std::out_of_range& e) {
65878       {
65879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65880       };
65881     } catch (std::exception& e) {
65882       {
65883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65884       };
65885     } catch (Dali::DaliException e) {
65886       {
65887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65888       };
65889     } catch (...) {
65890       {
65891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65892       };
65893     }
65894   }
65895
65896   jresult = result;
65897   return jresult;
65898 }
65899
65900
65901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65902   unsigned int jresult ;
65903   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65904   Dali::TouchEvent *arg2 = 0 ;
65905   bool result;
65906
65907   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65908   arg2 = (Dali::TouchEvent *)jarg2;
65909   if (!arg2) {
65910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65911     return 0;
65912   }
65913   {
65914     try {
65915       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65916     } catch (std::out_of_range& e) {
65917       {
65918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65919       };
65920     } catch (std::exception& e) {
65921       {
65922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65923       };
65924     } catch (Dali::DaliException e) {
65925       {
65926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65927       };
65928     } catch (...) {
65929       {
65930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65931       };
65932     }
65933   }
65934
65935   jresult = result;
65936   return jresult;
65937 }
65938
65939
65940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65941   unsigned int jresult ;
65942   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65943   Dali::TouchEvent *arg2 = 0 ;
65944   bool result;
65945
65946   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65947   arg2 = (Dali::TouchEvent *)jarg2;
65948   if (!arg2) {
65949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65950     return 0;
65951   }
65952   {
65953     try {
65954       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65955     } catch (std::out_of_range& e) {
65956       {
65957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65958       };
65959     } catch (std::exception& e) {
65960       {
65961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65962       };
65963     } catch (Dali::DaliException e) {
65964       {
65965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65966       };
65967     } catch (...) {
65968       {
65969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65970       };
65971     }
65972   }
65973
65974   jresult = result;
65975   return jresult;
65976 }
65977
65978
65979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
65980   unsigned int jresult ;
65981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65982   bool arg2 ;
65983   bool result;
65984
65985   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65986   arg2 = jarg2 ? true : false;
65987   {
65988     try {
65989       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
65990     } catch (std::out_of_range& e) {
65991       {
65992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65993       };
65994     } catch (std::exception& e) {
65995       {
65996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65997       };
65998     } catch (Dali::DaliException e) {
65999       {
66000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66001       };
66002     } catch (...) {
66003       {
66004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66005       };
66006     }
66007   }
66008
66009   jresult = result;
66010   return jresult;
66011 }
66012
66013
66014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66015   unsigned int jresult ;
66016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66017   bool arg2 ;
66018   bool result;
66019
66020   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66021   arg2 = jarg2 ? true : false;
66022   {
66023     try {
66024       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66025     } catch (std::out_of_range& e) {
66026       {
66027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66028       };
66029     } catch (std::exception& e) {
66030       {
66031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66032       };
66033     } catch (Dali::DaliException e) {
66034       {
66035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66036       };
66037     } catch (...) {
66038       {
66039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66040       };
66041     }
66042   }
66043
66044   jresult = result;
66045   return jresult;
66046 }
66047
66048
66049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66050   unsigned int jresult ;
66051   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66052   bool result;
66053
66054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66055   {
66056     try {
66057       result = (bool)(arg1)->OnAccessibilityZoom();
66058     } catch (std::out_of_range& e) {
66059       {
66060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66061       };
66062     } catch (std::exception& e) {
66063       {
66064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66065       };
66066     } catch (Dali::DaliException e) {
66067       {
66068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66069       };
66070     } catch (...) {
66071       {
66072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66073       };
66074     }
66075   }
66076
66077   jresult = result;
66078   return jresult;
66079 }
66080
66081
66082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66083   unsigned int jresult ;
66084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66085   bool result;
66086
66087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66088   {
66089     try {
66090       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66091     } catch (std::out_of_range& e) {
66092       {
66093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66094       };
66095     } catch (std::exception& e) {
66096       {
66097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66098       };
66099     } catch (Dali::DaliException e) {
66100       {
66101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66102       };
66103     } catch (...) {
66104       {
66105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66106       };
66107     }
66108   }
66109
66110   jresult = result;
66111   return jresult;
66112 }
66113
66114
66115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66117
66118   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66119   {
66120     try {
66121       (arg1)->OnKeyInputFocusGained();
66122     } catch (std::out_of_range& e) {
66123       {
66124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66125       };
66126     } catch (std::exception& e) {
66127       {
66128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66129       };
66130     } catch (Dali::DaliException e) {
66131       {
66132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66133       };
66134     } catch (...) {
66135       {
66136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66137       };
66138     }
66139   }
66140
66141 }
66142
66143
66144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66145   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66146
66147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66148   {
66149     try {
66150       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66151     } catch (std::out_of_range& e) {
66152       {
66153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66154       };
66155     } catch (std::exception& e) {
66156       {
66157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66158       };
66159     } catch (Dali::DaliException e) {
66160       {
66161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66162       };
66163     } catch (...) {
66164       {
66165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66166       };
66167     }
66168   }
66169
66170 }
66171
66172
66173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66174   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66175
66176   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66177   {
66178     try {
66179       (arg1)->OnKeyInputFocusLost();
66180     } catch (std::out_of_range& e) {
66181       {
66182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66183       };
66184     } catch (std::exception& e) {
66185       {
66186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66187       };
66188     } catch (Dali::DaliException e) {
66189       {
66190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66191       };
66192     } catch (...) {
66193       {
66194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66195       };
66196     }
66197   }
66198
66199 }
66200
66201
66202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66204
66205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66206   {
66207     try {
66208       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66209     } catch (std::out_of_range& e) {
66210       {
66211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66212       };
66213     } catch (std::exception& e) {
66214       {
66215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66216       };
66217     } catch (Dali::DaliException e) {
66218       {
66219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66220       };
66221     } catch (...) {
66222       {
66223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66224       };
66225     }
66226   }
66227
66228 }
66229
66230
66231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66232   void * jresult ;
66233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66234   Dali::Actor arg2 ;
66235   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66236   bool arg4 ;
66237   Dali::Actor *argp2 ;
66238   Dali::Actor result;
66239
66240   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66241   argp2 = (Dali::Actor *)jarg2;
66242   if (!argp2) {
66243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66244     return 0;
66245   }
66246   arg2 = *argp2;
66247   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66248   arg4 = jarg4 ? true : false;
66249   {
66250     try {
66251       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66252     } catch (std::out_of_range& e) {
66253       {
66254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66255       };
66256     } catch (std::exception& e) {
66257       {
66258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66259       };
66260     } catch (Dali::DaliException e) {
66261       {
66262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66263       };
66264     } catch (...) {
66265       {
66266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66267       };
66268     }
66269   }
66270
66271   jresult = new Dali::Actor((const Dali::Actor &)result);
66272   return jresult;
66273 }
66274
66275
66276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66277   void * jresult ;
66278   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66279   Dali::Actor arg2 ;
66280   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66281   bool arg4 ;
66282   Dali::Actor *argp2 ;
66283   Dali::Actor result;
66284
66285   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66286   argp2 = (Dali::Actor *)jarg2;
66287   if (!argp2) {
66288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66289     return 0;
66290   }
66291   arg2 = *argp2;
66292   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66293   arg4 = jarg4 ? true : false;
66294   {
66295     try {
66296       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66297     } catch (std::out_of_range& e) {
66298       {
66299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66300       };
66301     } catch (std::exception& e) {
66302       {
66303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66304       };
66305     } catch (Dali::DaliException e) {
66306       {
66307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66308       };
66309     } catch (...) {
66310       {
66311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66312       };
66313     }
66314   }
66315
66316   jresult = new Dali::Actor((const Dali::Actor &)result);
66317   return jresult;
66318 }
66319
66320
66321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66322   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66323   Dali::Actor arg2 ;
66324   Dali::Actor *argp2 ;
66325
66326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66327   argp2 = (Dali::Actor *)jarg2;
66328   if (!argp2) {
66329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66330     return ;
66331   }
66332   arg2 = *argp2;
66333   {
66334     try {
66335       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66336     } catch (std::out_of_range& e) {
66337       {
66338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66339       };
66340     } catch (std::exception& e) {
66341       {
66342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66343       };
66344     } catch (Dali::DaliException e) {
66345       {
66346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66347       };
66348     } catch (...) {
66349       {
66350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66351       };
66352     }
66353   }
66354
66355 }
66356
66357
66358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66360   Dali::Actor arg2 ;
66361   Dali::Actor *argp2 ;
66362
66363   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66364   argp2 = (Dali::Actor *)jarg2;
66365   if (!argp2) {
66366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66367     return ;
66368   }
66369   arg2 = *argp2;
66370   {
66371     try {
66372       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66373     } catch (std::out_of_range& e) {
66374       {
66375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66376       };
66377     } catch (std::exception& e) {
66378       {
66379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66380       };
66381     } catch (Dali::DaliException e) {
66382       {
66383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66384       };
66385     } catch (...) {
66386       {
66387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66388       };
66389     }
66390   }
66391
66392 }
66393
66394
66395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66396   unsigned int jresult ;
66397   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66398   bool result;
66399
66400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66401   {
66402     try {
66403       result = (bool)(arg1)->OnKeyboardEnter();
66404     } catch (std::out_of_range& e) {
66405       {
66406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66407       };
66408     } catch (std::exception& e) {
66409       {
66410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66411       };
66412     } catch (Dali::DaliException e) {
66413       {
66414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66415       };
66416     } catch (...) {
66417       {
66418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66419       };
66420     }
66421   }
66422
66423   jresult = result;
66424   return jresult;
66425 }
66426
66427
66428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66429   unsigned int jresult ;
66430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66431   bool result;
66432
66433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66434   {
66435     try {
66436       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66437     } catch (std::out_of_range& e) {
66438       {
66439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66440       };
66441     } catch (std::exception& e) {
66442       {
66443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66444       };
66445     } catch (Dali::DaliException e) {
66446       {
66447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66448       };
66449     } catch (...) {
66450       {
66451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66452       };
66453     }
66454   }
66455
66456   jresult = result;
66457   return jresult;
66458 }
66459
66460
66461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66463   Dali::PinchGesture *arg2 = 0 ;
66464
66465   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66466   arg2 = (Dali::PinchGesture *)jarg2;
66467   if (!arg2) {
66468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66469     return ;
66470   }
66471   {
66472     try {
66473       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66474     } catch (std::out_of_range& e) {
66475       {
66476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66477       };
66478     } catch (std::exception& e) {
66479       {
66480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66481       };
66482     } catch (Dali::DaliException e) {
66483       {
66484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66485       };
66486     } catch (...) {
66487       {
66488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66489       };
66490     }
66491   }
66492
66493 }
66494
66495
66496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66497   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66498   Dali::PinchGesture *arg2 = 0 ;
66499
66500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66501   arg2 = (Dali::PinchGesture *)jarg2;
66502   if (!arg2) {
66503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66504     return ;
66505   }
66506   {
66507     try {
66508       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66509     } catch (std::out_of_range& e) {
66510       {
66511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66512       };
66513     } catch (std::exception& e) {
66514       {
66515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66516       };
66517     } catch (Dali::DaliException e) {
66518       {
66519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66520       };
66521     } catch (...) {
66522       {
66523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66524       };
66525     }
66526   }
66527
66528 }
66529
66530
66531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66532   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66533   Dali::PanGesture *arg2 = 0 ;
66534
66535   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66536   arg2 = (Dali::PanGesture *)jarg2;
66537   if (!arg2) {
66538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66539     return ;
66540   }
66541   {
66542     try {
66543       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66544     } catch (std::out_of_range& e) {
66545       {
66546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66547       };
66548     } catch (std::exception& e) {
66549       {
66550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66551       };
66552     } catch (Dali::DaliException e) {
66553       {
66554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66555       };
66556     } catch (...) {
66557       {
66558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66559       };
66560     }
66561   }
66562
66563 }
66564
66565
66566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66567   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66568   Dali::PanGesture *arg2 = 0 ;
66569
66570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66571   arg2 = (Dali::PanGesture *)jarg2;
66572   if (!arg2) {
66573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66574     return ;
66575   }
66576   {
66577     try {
66578       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66579     } catch (std::out_of_range& e) {
66580       {
66581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66582       };
66583     } catch (std::exception& e) {
66584       {
66585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66586       };
66587     } catch (Dali::DaliException e) {
66588       {
66589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66590       };
66591     } catch (...) {
66592       {
66593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66594       };
66595     }
66596   }
66597
66598 }
66599
66600
66601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66602   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66603   Dali::TapGesture *arg2 = 0 ;
66604
66605   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66606   arg2 = (Dali::TapGesture *)jarg2;
66607   if (!arg2) {
66608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66609     return ;
66610   }
66611   {
66612     try {
66613       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66614     } catch (std::out_of_range& e) {
66615       {
66616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66617       };
66618     } catch (std::exception& e) {
66619       {
66620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66621       };
66622     } catch (Dali::DaliException e) {
66623       {
66624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66625       };
66626     } catch (...) {
66627       {
66628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66629       };
66630     }
66631   }
66632
66633 }
66634
66635
66636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66637   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66638   Dali::TapGesture *arg2 = 0 ;
66639
66640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66641   arg2 = (Dali::TapGesture *)jarg2;
66642   if (!arg2) {
66643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66644     return ;
66645   }
66646   {
66647     try {
66648       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66649     } catch (std::out_of_range& e) {
66650       {
66651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66652       };
66653     } catch (std::exception& e) {
66654       {
66655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66656       };
66657     } catch (Dali::DaliException e) {
66658       {
66659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66660       };
66661     } catch (...) {
66662       {
66663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66664       };
66665     }
66666   }
66667
66668 }
66669
66670
66671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66673   Dali::LongPressGesture *arg2 = 0 ;
66674
66675   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66676   arg2 = (Dali::LongPressGesture *)jarg2;
66677   if (!arg2) {
66678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66679     return ;
66680   }
66681   {
66682     try {
66683       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66684     } catch (std::out_of_range& e) {
66685       {
66686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66687       };
66688     } catch (std::exception& e) {
66689       {
66690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66691       };
66692     } catch (Dali::DaliException e) {
66693       {
66694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66695       };
66696     } catch (...) {
66697       {
66698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66699       };
66700     }
66701   }
66702
66703 }
66704
66705
66706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66708   Dali::LongPressGesture *arg2 = 0 ;
66709
66710   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66711   arg2 = (Dali::LongPressGesture *)jarg2;
66712   if (!arg2) {
66713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66714     return ;
66715   }
66716   {
66717     try {
66718       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66719     } catch (std::out_of_range& e) {
66720       {
66721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66722       };
66723     } catch (std::exception& e) {
66724       {
66725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66726       };
66727     } catch (Dali::DaliException e) {
66728       {
66729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66730       };
66731     } catch (...) {
66732       {
66733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66734       };
66735     }
66736   }
66737
66738 }
66739
66740
66741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66743   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66744   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66745
66746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66747   arg2 = (Dali::SlotObserver *)jarg2;
66748   arg3 = (Dali::CallbackBase *)jarg3;
66749   {
66750     try {
66751       (arg1)->SignalConnected(arg2,arg3);
66752     } catch (std::out_of_range& e) {
66753       {
66754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66755       };
66756     } catch (std::exception& e) {
66757       {
66758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66759       };
66760     } catch (Dali::DaliException e) {
66761       {
66762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66763       };
66764     } catch (...) {
66765       {
66766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66767       };
66768     }
66769   }
66770
66771 }
66772
66773
66774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66776   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66777   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66778
66779   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66780   arg2 = (Dali::SlotObserver *)jarg2;
66781   arg3 = (Dali::CallbackBase *)jarg3;
66782   {
66783     try {
66784       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66785     } catch (std::out_of_range& e) {
66786       {
66787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66788       };
66789     } catch (std::exception& e) {
66790       {
66791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66792       };
66793     } catch (Dali::DaliException e) {
66794       {
66795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66796       };
66797     } catch (...) {
66798       {
66799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66800       };
66801     }
66802   }
66803
66804 }
66805
66806
66807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66808   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66809   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66810   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66811
66812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66813   arg2 = (Dali::SlotObserver *)jarg2;
66814   arg3 = (Dali::CallbackBase *)jarg3;
66815   {
66816     try {
66817       (arg1)->SignalDisconnected(arg2,arg3);
66818     } catch (std::out_of_range& e) {
66819       {
66820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66821       };
66822     } catch (std::exception& e) {
66823       {
66824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66825       };
66826     } catch (Dali::DaliException e) {
66827       {
66828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66829       };
66830     } catch (...) {
66831       {
66832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66833       };
66834     }
66835   }
66836
66837 }
66838
66839
66840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66841   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66842   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66843   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66844
66845   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66846   arg2 = (Dali::SlotObserver *)jarg2;
66847   arg3 = (Dali::CallbackBase *)jarg3;
66848   {
66849     try {
66850       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66851     } catch (std::out_of_range& e) {
66852       {
66853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66854       };
66855     } catch (std::exception& e) {
66856       {
66857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66858       };
66859     } catch (Dali::DaliException e) {
66860       {
66861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66862       };
66863     } catch (...) {
66864       {
66865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66866       };
66867     }
66868   }
66869
66870 }
66871
66872
66873 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) {
66874   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66875   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66876   if (director) {
66877     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);
66878   }
66879 }
66880
66881
66882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66883   void * jresult ;
66884   Dali::Toolkit::Control *arg1 = 0 ;
66885   Dali::Toolkit::Internal::Control *result = 0 ;
66886
66887   arg1 = (Dali::Toolkit::Control *)jarg1;
66888   if (!arg1) {
66889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66890     return 0;
66891   }
66892   {
66893     try {
66894       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66895     } catch (std::out_of_range& e) {
66896       {
66897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66898       };
66899     } catch (std::exception& e) {
66900       {
66901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66902       };
66903     } catch (Dali::DaliException e) {
66904       {
66905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66906       };
66907     } catch (...) {
66908       {
66909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66910       };
66911     }
66912   }
66913
66914   jresult = (void *)result;
66915   return jresult;
66916 }
66917
66918
66919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66920   int jresult ;
66921   int result;
66922
66923   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66924   jresult = (int)result;
66925   return jresult;
66926 }
66927
66928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
66929   int jresult ;
66930   int result;
66931
66932   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
66933   jresult = (int)result;
66934   return jresult;
66935 }
66936
66937
66938 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
66939   int jresult ;
66940   int result;
66941
66942   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
66943   jresult = (int)result;
66944   return jresult;
66945 }
66946
66947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
66948   int jresult ;
66949   int result;
66950
66951   result = (int)Dali::Toolkit::Control::Property::MARGIN;
66952   jresult = (int)result;
66953   return jresult;
66954 }
66955
66956
66957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
66958   int jresult ;
66959   int result;
66960
66961   result = (int)Dali::Toolkit::Control::Property::PADDING;
66962   jresult = (int)result;
66963   return jresult;
66964 }
66965
66966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
66967   void * jresult ;
66968   Dali::Toolkit::Control::Property *result = 0 ;
66969
66970   {
66971     try {
66972       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
66973     } catch (std::out_of_range& e) {
66974       {
66975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66976       };
66977     } catch (std::exception& e) {
66978       {
66979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66980       };
66981     } catch (Dali::DaliException e) {
66982       {
66983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66984       };
66985     } catch (...) {
66986       {
66987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66988       };
66989     }
66990   }
66991
66992   jresult = (void *)result;
66993   return jresult;
66994 }
66995
66996
66997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
66998   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
66999
67000   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67001   {
67002     try {
67003       delete arg1;
67004     } catch (std::out_of_range& e) {
67005       {
67006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67007       };
67008     } catch (std::exception& e) {
67009       {
67010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67011       };
67012     } catch (Dali::DaliException e) {
67013       {
67014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67015       };
67016     } catch (...) {
67017       {
67018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67019       };
67020     }
67021   }
67022
67023 }
67024
67025
67026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67027   void * jresult ;
67028   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67029
67030   {
67031     try {
67032       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67033     } catch (std::out_of_range& e) {
67034       {
67035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67036       };
67037     } catch (std::exception& e) {
67038       {
67039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67040       };
67041     } catch (Dali::DaliException e) {
67042       {
67043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67044       };
67045     } catch (...) {
67046       {
67047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67048       };
67049     }
67050   }
67051
67052   jresult = (void *)result;
67053   return jresult;
67054 }
67055
67056
67057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67058   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67059
67060   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67061   {
67062     try {
67063       delete arg1;
67064     } catch (std::out_of_range& e) {
67065       {
67066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67067       };
67068     } catch (std::exception& e) {
67069       {
67070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67071       };
67072     } catch (Dali::DaliException e) {
67073       {
67074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67075       };
67076     } catch (...) {
67077       {
67078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67079       };
67080     }
67081   }
67082
67083 }
67084
67085
67086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67087   void * jresult ;
67088   Dali::Toolkit::Control result;
67089
67090   {
67091     try {
67092       result = Dali::Toolkit::Control::New();
67093     } catch (std::out_of_range& e) {
67094       {
67095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67096       };
67097     } catch (std::exception& e) {
67098       {
67099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67100       };
67101     } catch (Dali::DaliException e) {
67102       {
67103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67104       };
67105     } catch (...) {
67106       {
67107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67108       };
67109     }
67110   }
67111
67112   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67113   return jresult;
67114 }
67115
67116
67117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67118   void * jresult ;
67119   Dali::Toolkit::Control *result = 0 ;
67120
67121   {
67122     try {
67123       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67124     } catch (std::out_of_range& e) {
67125       {
67126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67127       };
67128     } catch (std::exception& e) {
67129       {
67130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67131       };
67132     } catch (Dali::DaliException e) {
67133       {
67134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67135       };
67136     } catch (...) {
67137       {
67138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67139       };
67140     }
67141   }
67142
67143   jresult = (void *)result;
67144   return jresult;
67145 }
67146
67147
67148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67149   void * jresult ;
67150   Dali::Toolkit::Control *arg1 = 0 ;
67151   Dali::Toolkit::Control *result = 0 ;
67152
67153   arg1 = (Dali::Toolkit::Control *)jarg1;
67154   if (!arg1) {
67155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67156     return 0;
67157   }
67158   {
67159     try {
67160       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67161     } catch (std::out_of_range& e) {
67162       {
67163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67164       };
67165     } catch (std::exception& e) {
67166       {
67167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67168       };
67169     } catch (Dali::DaliException e) {
67170       {
67171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67172       };
67173     } catch (...) {
67174       {
67175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67176       };
67177     }
67178   }
67179
67180   jresult = (void *)result;
67181   return jresult;
67182 }
67183
67184
67185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67186   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67187
67188   arg1 = (Dali::Toolkit::Control *)jarg1;
67189   {
67190     try {
67191       delete arg1;
67192     } catch (std::out_of_range& e) {
67193       {
67194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67195       };
67196     } catch (std::exception& e) {
67197       {
67198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67199       };
67200     } catch (Dali::DaliException e) {
67201       {
67202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67203       };
67204     } catch (...) {
67205       {
67206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67207       };
67208     }
67209   }
67210
67211 }
67212
67213
67214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67215   void * jresult ;
67216   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67217   Dali::Toolkit::Control *arg2 = 0 ;
67218   Dali::Toolkit::Control *result = 0 ;
67219
67220   arg1 = (Dali::Toolkit::Control *)jarg1;
67221   arg2 = (Dali::Toolkit::Control *)jarg2;
67222   if (!arg2) {
67223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67224     return 0;
67225   }
67226   {
67227     try {
67228       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67229     } catch (std::out_of_range& e) {
67230       {
67231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67232       };
67233     } catch (std::exception& e) {
67234       {
67235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67236       };
67237     } catch (Dali::DaliException e) {
67238       {
67239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67240       };
67241     } catch (...) {
67242       {
67243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67244       };
67245     }
67246   }
67247
67248   jresult = (void *)result;
67249   return jresult;
67250 }
67251
67252
67253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67254   void * jresult ;
67255   Dali::BaseHandle arg1 ;
67256   Dali::BaseHandle *argp1 ;
67257   Dali::Toolkit::Control result;
67258
67259   argp1 = (Dali::BaseHandle *)jarg1;
67260   if (!argp1) {
67261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67262     return 0;
67263   }
67264   arg1 = *argp1;
67265   {
67266     try {
67267       result = Dali::Toolkit::Control::DownCast(arg1);
67268     } catch (std::out_of_range& e) {
67269       {
67270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67271       };
67272     } catch (std::exception& e) {
67273       {
67274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67275       };
67276     } catch (Dali::DaliException e) {
67277       {
67278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67279       };
67280     } catch (...) {
67281       {
67282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67283       };
67284     }
67285   }
67286
67287   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67288   return jresult;
67289 }
67290
67291
67292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67293   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67294
67295   arg1 = (Dali::Toolkit::Control *)jarg1;
67296   {
67297     try {
67298       (arg1)->SetKeyInputFocus();
67299     } catch (std::out_of_range& e) {
67300       {
67301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67302       };
67303     } catch (std::exception& e) {
67304       {
67305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67306       };
67307     } catch (Dali::DaliException e) {
67308       {
67309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67310       };
67311     } catch (...) {
67312       {
67313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67314       };
67315     }
67316   }
67317
67318 }
67319
67320
67321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67322   unsigned int jresult ;
67323   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67324   bool result;
67325
67326   arg1 = (Dali::Toolkit::Control *)jarg1;
67327   {
67328     try {
67329       result = (bool)(arg1)->HasKeyInputFocus();
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 = result;
67350   return jresult;
67351 }
67352
67353
67354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67355   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67356
67357   arg1 = (Dali::Toolkit::Control *)jarg1;
67358   {
67359     try {
67360       (arg1)->ClearKeyInputFocus();
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
67383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67384   void * jresult ;
67385   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67386   Dali::PinchGestureDetector result;
67387
67388   arg1 = (Dali::Toolkit::Control *)jarg1;
67389   {
67390     try {
67391       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67392     } catch (std::out_of_range& e) {
67393       {
67394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67395       };
67396     } catch (std::exception& e) {
67397       {
67398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67399       };
67400     } catch (Dali::DaliException e) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67403       };
67404     } catch (...) {
67405       {
67406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67407       };
67408     }
67409   }
67410
67411   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67412   return jresult;
67413 }
67414
67415
67416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67417   void * jresult ;
67418   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67419   Dali::PanGestureDetector result;
67420
67421   arg1 = (Dali::Toolkit::Control *)jarg1;
67422   {
67423     try {
67424       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67425     } catch (std::out_of_range& e) {
67426       {
67427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67428       };
67429     } catch (std::exception& e) {
67430       {
67431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67432       };
67433     } catch (Dali::DaliException e) {
67434       {
67435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67436       };
67437     } catch (...) {
67438       {
67439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67440       };
67441     }
67442   }
67443
67444   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67445   return jresult;
67446 }
67447
67448
67449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67450   void * jresult ;
67451   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67452   Dali::TapGestureDetector result;
67453
67454   arg1 = (Dali::Toolkit::Control *)jarg1;
67455   {
67456     try {
67457       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67458     } catch (std::out_of_range& e) {
67459       {
67460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67461       };
67462     } catch (std::exception& e) {
67463       {
67464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67465       };
67466     } catch (Dali::DaliException e) {
67467       {
67468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67469       };
67470     } catch (...) {
67471       {
67472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67473       };
67474     }
67475   }
67476
67477   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67478   return jresult;
67479 }
67480
67481
67482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67483   void * jresult ;
67484   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67485   Dali::LongPressGestureDetector result;
67486
67487   arg1 = (Dali::Toolkit::Control *)jarg1;
67488   {
67489     try {
67490       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67491     } catch (std::out_of_range& e) {
67492       {
67493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67494       };
67495     } catch (std::exception& e) {
67496       {
67497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67498       };
67499     } catch (Dali::DaliException e) {
67500       {
67501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67502       };
67503     } catch (...) {
67504       {
67505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67506       };
67507     }
67508   }
67509
67510   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67511   return jresult;
67512 }
67513
67514
67515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67516   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67517   std::string *arg2 = 0 ;
67518
67519   arg1 = (Dali::Toolkit::Control *)jarg1;
67520   if (!jarg2) {
67521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67522     return ;
67523   }
67524   std::string arg2_str(jarg2);
67525   arg2 = &arg2_str;
67526   {
67527     try {
67528       (arg1)->SetStyleName((std::string const &)*arg2);
67529     } catch (std::out_of_range& e) {
67530       {
67531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67532       };
67533     } catch (std::exception& e) {
67534       {
67535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67536       };
67537     } catch (Dali::DaliException e) {
67538       {
67539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67540       };
67541     } catch (...) {
67542       {
67543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67544       };
67545     }
67546   }
67547
67548
67549   //argout typemap for const std::string&
67550
67551 }
67552
67553
67554 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67555   char * jresult ;
67556   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67557   std::string *result = 0 ;
67558
67559   arg1 = (Dali::Toolkit::Control *)jarg1;
67560   {
67561     try {
67562       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67563     } catch (std::out_of_range& e) {
67564       {
67565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67566       };
67567     } catch (std::exception& e) {
67568       {
67569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67570       };
67571     } catch (Dali::DaliException e) {
67572       {
67573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67574       };
67575     } catch (...) {
67576       {
67577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67578       };
67579     }
67580   }
67581
67582   jresult = SWIG_csharp_string_callback(result->c_str());
67583   return jresult;
67584 }
67585
67586
67587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67588   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67589   Dali::Vector4 *arg2 = 0 ;
67590
67591   arg1 = (Dali::Toolkit::Control *)jarg1;
67592   arg2 = (Dali::Vector4 *)jarg2;
67593   if (!arg2) {
67594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67595     return ;
67596   }
67597   {
67598     try {
67599       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67600     } catch (std::out_of_range& e) {
67601       {
67602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67603       };
67604     } catch (std::exception& e) {
67605       {
67606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67607       };
67608     } catch (Dali::DaliException e) {
67609       {
67610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67611       };
67612     } catch (...) {
67613       {
67614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67615       };
67616     }
67617   }
67618
67619 }
67620
67621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67622   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67623
67624   arg1 = (Dali::Toolkit::Control *)jarg1;
67625   {
67626     try {
67627       (arg1)->ClearBackground();
67628     } catch (std::out_of_range& e) {
67629       {
67630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67631       };
67632     } catch (std::exception& e) {
67633       {
67634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67635       };
67636     } catch (Dali::DaliException e) {
67637       {
67638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67639       };
67640     } catch (...) {
67641       {
67642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67643       };
67644     }
67645   }
67646
67647 }
67648
67649
67650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67651   void * jresult ;
67652   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67653   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67654
67655   arg1 = (Dali::Toolkit::Control *)jarg1;
67656   {
67657     try {
67658       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67659     } catch (std::out_of_range& e) {
67660       {
67661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67662       };
67663     } catch (std::exception& e) {
67664       {
67665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67666       };
67667     } catch (Dali::DaliException e) {
67668       {
67669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67670       };
67671     } catch (...) {
67672       {
67673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67674       };
67675     }
67676   }
67677
67678   jresult = (void *)result;
67679   return jresult;
67680 }
67681
67682
67683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67684   void * jresult ;
67685   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67686   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67687
67688   arg1 = (Dali::Toolkit::Control *)jarg1;
67689   {
67690     try {
67691       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67692     } catch (std::out_of_range& e) {
67693       {
67694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67695       };
67696     } catch (std::exception& e) {
67697       {
67698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67699       };
67700     } catch (Dali::DaliException e) {
67701       {
67702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67703       };
67704     } catch (...) {
67705       {
67706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67707       };
67708     }
67709   }
67710
67711   jresult = (void *)result;
67712   return jresult;
67713 }
67714
67715
67716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67717   void * jresult ;
67718   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67719   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67720
67721   arg1 = (Dali::Toolkit::Control *)jarg1;
67722   {
67723     try {
67724       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67725     } catch (std::out_of_range& e) {
67726       {
67727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67728       };
67729     } catch (std::exception& e) {
67730       {
67731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67732       };
67733     } catch (Dali::DaliException e) {
67734       {
67735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67736       };
67737     } catch (...) {
67738       {
67739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67740       };
67741     }
67742   }
67743
67744   jresult = (void *)result;
67745   return jresult;
67746 }
67747
67748
67749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67750   void * jresult ;
67751   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67752   Dali::Toolkit::Control *result = 0 ;
67753
67754   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67755   if (!arg1) {
67756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67757     return 0;
67758   }
67759   {
67760     try {
67761       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67762     } catch (std::out_of_range& e) {
67763       {
67764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67765       };
67766     } catch (std::exception& e) {
67767       {
67768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67769       };
67770     } catch (Dali::DaliException e) {
67771       {
67772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67773       };
67774     } catch (...) {
67775       {
67776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67777       };
67778     }
67779   }
67780
67781   jresult = (void *)result;
67782   return jresult;
67783 }
67784
67785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67786 {
67787   int jresult;
67788   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67789   arg1 = (Dali::Toolkit::Control *)jarg1;
67790
67791   if (!arg1) {
67792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67793     return 0;
67794   }
67795
67796   Dali::Property::Index arg2 = 0 ;
67797   arg2 = (Dali::Property::Index)jarg2;
67798
67799   Toolkit::Visual::ResourceStatus result;
67800   {
67801     try {
67802       result = arg1->GetVisualResourceStatus(arg2);
67803     } catch (std::out_of_range& e) {
67804       {
67805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67806       };
67807     } catch (std::exception& e) {
67808       {
67809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67810       };
67811     } catch (...) {
67812       {
67813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67814       };
67815     }
67816   }
67817   jresult = (int)(result);
67818   return jresult;
67819 }
67820
67821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67822 {
67823   void * jresult;
67824   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67825   arg1 = (Dali::Toolkit::Control *)jarg1;
67826
67827   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67828
67829   Dali::Toolkit::TransitionData *arg2 = 0 ;
67830   Dali::Animation result;
67831
67832   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67833   if (!arg2) {
67834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67835     return 0;
67836   }
67837   {
67838     try {
67839       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67840     } catch (std::out_of_range& e) {
67841       {
67842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67843       };
67844     } catch (std::exception& e) {
67845       {
67846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67847       };
67848     } catch (Dali::DaliException e) {
67849       {
67850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67851       };
67852     } catch (...) {
67853       {
67854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67855       };
67856     }
67857   }
67858
67859   jresult = new Dali::Animation((const Dali::Animation &)result);
67860   return jresult;
67861 }
67862
67863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67864 {
67865   Dali::Toolkit::Control arg1;
67866   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67867
67868   if (!argp1) {
67869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67870   }
67871   arg1 = *argp1;
67872
67873   Dali::Property::Index arg2 = 0 ;
67874   arg2 = (Dali::Property::Index)jarg2;
67875
67876   Dali::Property::Index arg3 = 0 ;
67877   arg3 = (Dali::Property::Index)jarg3;
67878
67879   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67880
67881   {
67882     try {
67883       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67884     } catch (std::out_of_range& e) {
67885       {
67886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67887       };
67888     } catch (std::exception& e) {
67889       {
67890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67891       };
67892     } catch (...) {
67893       {
67894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67895       };
67896     }
67897   }
67898
67899
67900 }
67901
67902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67903   void * jresult ;
67904   Dali::Toolkit::Control *arg1 = 0 ;
67905   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67906
67907   arg1 = (Dali::Toolkit::Control *)jarg1;
67908   if (!arg1) {
67909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67910     return 0;
67911   }
67912   {
67913     try {
67914       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
67915     } catch (std::out_of_range& e) {
67916       {
67917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67918       };
67919     } catch (std::exception& e) {
67920       {
67921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67922       };
67923     } catch (Dali::DaliException e) {
67924       {
67925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67926       };
67927     } catch (...) {
67928       {
67929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67930       };
67931     }
67932   }
67933
67934   jresult = (void *)result;
67935   return jresult;
67936 }
67937
67938
67939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
67940   unsigned int jresult ;
67941   Dali::Toolkit::Control *arg1 = 0 ;
67942   bool result;
67943
67944   arg1 = (Dali::Toolkit::Control *)jarg1;
67945   if (!arg1) {
67946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67947     return 0;
67948   }
67949   {
67950     try {
67951       result = (bool)arg1->IsResourceReady();
67952     } catch (std::out_of_range& e) {
67953       {
67954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67955       };
67956     } catch (std::exception& e) {
67957       {
67958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67959       };
67960     } catch (Dali::DaliException e) {
67961       {
67962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67963       };
67964     } catch (...) {
67965       {
67966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67967       };
67968     }
67969   }
67970
67971   jresult = result;
67972   return jresult;
67973 }
67974
67975
67976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
67977   void * jresult ;
67978   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
67979
67980   {
67981     try {
67982       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
67983     } catch (std::out_of_range& e) {
67984       {
67985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67986       };
67987     } catch (std::exception& e) {
67988       {
67989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67990       };
67991     } catch (Dali::DaliException e) {
67992       {
67993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67994       };
67995     } catch (...) {
67996       {
67997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67998       };
67999     }
68000   }
68001
68002   jresult = (void *)result;
68003   return jresult;
68004 }
68005
68006
68007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68008   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68009
68010   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68011   {
68012     try {
68013       delete arg1;
68014     } catch (std::out_of_range& e) {
68015       {
68016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68017       };
68018     } catch (std::exception& e) {
68019       {
68020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68021       };
68022     } catch (Dali::DaliException e) {
68023       {
68024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68025       };
68026     } catch (...) {
68027       {
68028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68029       };
68030     }
68031   }
68032
68033 }
68034
68035
68036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68037   void * jresult ;
68038   Dali::Toolkit::KeyInputFocusManager result;
68039
68040   {
68041     try {
68042       result = Dali::Toolkit::KeyInputFocusManager::Get();
68043     } catch (std::out_of_range& e) {
68044       {
68045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68046       };
68047     } catch (std::exception& e) {
68048       {
68049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68050       };
68051     } catch (Dali::DaliException e) {
68052       {
68053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68054       };
68055     } catch (...) {
68056       {
68057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68058       };
68059     }
68060   }
68061
68062   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68063   return jresult;
68064 }
68065
68066
68067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68068   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68069   Dali::Toolkit::Control arg2 ;
68070   Dali::Toolkit::Control *argp2 ;
68071
68072   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68073   argp2 = (Dali::Toolkit::Control *)jarg2;
68074   if (!argp2) {
68075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68076     return ;
68077   }
68078   arg2 = *argp2;
68079   {
68080     try {
68081       (arg1)->SetFocus(arg2);
68082     } catch (std::out_of_range& e) {
68083       {
68084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68085       };
68086     } catch (std::exception& e) {
68087       {
68088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68089       };
68090     } catch (Dali::DaliException e) {
68091       {
68092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68093       };
68094     } catch (...) {
68095       {
68096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68097       };
68098     }
68099   }
68100
68101 }
68102
68103
68104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68105   void * jresult ;
68106   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68107   Dali::Toolkit::Control result;
68108
68109   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68110   {
68111     try {
68112       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68113     } catch (std::out_of_range& e) {
68114       {
68115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68116       };
68117     } catch (std::exception& e) {
68118       {
68119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68120       };
68121     } catch (Dali::DaliException e) {
68122       {
68123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68124       };
68125     } catch (...) {
68126       {
68127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68128       };
68129     }
68130   }
68131
68132   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68133   return jresult;
68134 }
68135
68136
68137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68138   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68139   Dali::Toolkit::Control arg2 ;
68140   Dali::Toolkit::Control *argp2 ;
68141
68142   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68143   argp2 = (Dali::Toolkit::Control *)jarg2;
68144   if (!argp2) {
68145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68146     return ;
68147   }
68148   arg2 = *argp2;
68149   {
68150     try {
68151       (arg1)->RemoveFocus(arg2);
68152     } catch (std::out_of_range& e) {
68153       {
68154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68155       };
68156     } catch (std::exception& e) {
68157       {
68158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68159       };
68160     } catch (Dali::DaliException e) {
68161       {
68162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68163       };
68164     } catch (...) {
68165       {
68166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68167       };
68168     }
68169   }
68170
68171 }
68172
68173
68174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68175   void * jresult ;
68176   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68177   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68178
68179   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68180   {
68181     try {
68182       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68183     } catch (std::out_of_range& e) {
68184       {
68185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68186       };
68187     } catch (std::exception& e) {
68188       {
68189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68190       };
68191     } catch (Dali::DaliException e) {
68192       {
68193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68194       };
68195     } catch (...) {
68196       {
68197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68198       };
68199     }
68200   }
68201
68202   jresult = (void *)result;
68203   return jresult;
68204 }
68205
68206
68207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68208   void * jresult ;
68209   Dali::Toolkit::Alignment::Padding *result = 0 ;
68210
68211   {
68212     try {
68213       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68214     } catch (std::out_of_range& e) {
68215       {
68216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68217       };
68218     } catch (std::exception& e) {
68219       {
68220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68221       };
68222     } catch (Dali::DaliException e) {
68223       {
68224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68225       };
68226     } catch (...) {
68227       {
68228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68229       };
68230     }
68231   }
68232
68233   jresult = (void *)result;
68234   return jresult;
68235 }
68236
68237
68238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68239   void * jresult ;
68240   float arg1 ;
68241   float arg2 ;
68242   float arg3 ;
68243   float arg4 ;
68244   Dali::Toolkit::Alignment::Padding *result = 0 ;
68245
68246   arg1 = (float)jarg1;
68247   arg2 = (float)jarg2;
68248   arg3 = (float)jarg3;
68249   arg4 = (float)jarg4;
68250   {
68251     try {
68252       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68253     } catch (std::out_of_range& e) {
68254       {
68255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68256       };
68257     } catch (std::exception& e) {
68258       {
68259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68260       };
68261     } catch (Dali::DaliException e) {
68262       {
68263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68264       };
68265     } catch (...) {
68266       {
68267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68268       };
68269     }
68270   }
68271
68272   jresult = (void *)result;
68273   return jresult;
68274 }
68275
68276
68277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68278   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68279   float arg2 ;
68280
68281   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68282   arg2 = (float)jarg2;
68283   if (arg1) (arg1)->left = arg2;
68284 }
68285
68286
68287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68288   float jresult ;
68289   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68290   float result;
68291
68292   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68293   result = (float) ((arg1)->left);
68294   jresult = result;
68295   return jresult;
68296 }
68297
68298
68299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68300   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68301   float arg2 ;
68302
68303   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68304   arg2 = (float)jarg2;
68305   if (arg1) (arg1)->right = arg2;
68306 }
68307
68308
68309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68310   float jresult ;
68311   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68312   float result;
68313
68314   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68315   result = (float) ((arg1)->right);
68316   jresult = result;
68317   return jresult;
68318 }
68319
68320
68321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68322   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68323   float arg2 ;
68324
68325   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68326   arg2 = (float)jarg2;
68327   if (arg1) (arg1)->top = arg2;
68328 }
68329
68330
68331 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68332   float jresult ;
68333   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68334   float result;
68335
68336   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68337   result = (float) ((arg1)->top);
68338   jresult = result;
68339   return jresult;
68340 }
68341
68342
68343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68344   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68345   float arg2 ;
68346
68347   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68348   arg2 = (float)jarg2;
68349   if (arg1) (arg1)->bottom = arg2;
68350 }
68351
68352
68353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68354   float jresult ;
68355   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68356   float result;
68357
68358   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68359   result = (float) ((arg1)->bottom);
68360   jresult = result;
68361   return jresult;
68362 }
68363
68364
68365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68366   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68367
68368   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68369   {
68370     try {
68371       delete arg1;
68372     } catch (std::out_of_range& e) {
68373       {
68374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68375       };
68376     } catch (std::exception& e) {
68377       {
68378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68379       };
68380     } catch (Dali::DaliException e) {
68381       {
68382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68383       };
68384     } catch (...) {
68385       {
68386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68387       };
68388     }
68389   }
68390
68391 }
68392
68393
68394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68395   void * jresult ;
68396   Dali::Toolkit::Alignment *result = 0 ;
68397
68398   {
68399     try {
68400       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68401     } catch (std::out_of_range& e) {
68402       {
68403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68404       };
68405     } catch (std::exception& e) {
68406       {
68407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68408       };
68409     } catch (Dali::DaliException e) {
68410       {
68411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68412       };
68413     } catch (...) {
68414       {
68415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68416       };
68417     }
68418   }
68419
68420   jresult = (void *)result;
68421   return jresult;
68422 }
68423
68424
68425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68426   void * jresult ;
68427   Dali::Toolkit::Alignment::Type arg1 ;
68428   Dali::Toolkit::Alignment::Type arg2 ;
68429   Dali::Toolkit::Alignment result;
68430
68431   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68432   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68433   {
68434     try {
68435       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68436     } catch (std::out_of_range& e) {
68437       {
68438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68439       };
68440     } catch (std::exception& e) {
68441       {
68442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68443       };
68444     } catch (Dali::DaliException e) {
68445       {
68446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68447       };
68448     } catch (...) {
68449       {
68450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68451       };
68452     }
68453   }
68454
68455   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68456   return jresult;
68457 }
68458
68459
68460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68461   void * jresult ;
68462   Dali::Toolkit::Alignment::Type arg1 ;
68463   Dali::Toolkit::Alignment result;
68464
68465   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68466   {
68467     try {
68468       result = Dali::Toolkit::Alignment::New(arg1);
68469     } catch (std::out_of_range& e) {
68470       {
68471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68472       };
68473     } catch (std::exception& e) {
68474       {
68475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68476       };
68477     } catch (Dali::DaliException e) {
68478       {
68479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68480       };
68481     } catch (...) {
68482       {
68483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68484       };
68485     }
68486   }
68487
68488   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68489   return jresult;
68490 }
68491
68492
68493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68494   void * jresult ;
68495   Dali::Toolkit::Alignment result;
68496
68497   {
68498     try {
68499       result = Dali::Toolkit::Alignment::New();
68500     } catch (std::out_of_range& e) {
68501       {
68502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68503       };
68504     } catch (std::exception& e) {
68505       {
68506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68507       };
68508     } catch (Dali::DaliException e) {
68509       {
68510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68511       };
68512     } catch (...) {
68513       {
68514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68515       };
68516     }
68517   }
68518
68519   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68520   return jresult;
68521 }
68522
68523
68524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68525   void * jresult ;
68526   Dali::Toolkit::Alignment *arg1 = 0 ;
68527   Dali::Toolkit::Alignment *result = 0 ;
68528
68529   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68530   if (!arg1) {
68531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68532     return 0;
68533   }
68534   {
68535     try {
68536       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68537     } catch (std::out_of_range& e) {
68538       {
68539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68540       };
68541     } catch (std::exception& e) {
68542       {
68543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68544       };
68545     } catch (Dali::DaliException e) {
68546       {
68547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68548       };
68549     } catch (...) {
68550       {
68551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68552       };
68553     }
68554   }
68555
68556   jresult = (void *)result;
68557   return jresult;
68558 }
68559
68560
68561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68562   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68563
68564   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68565   {
68566     try {
68567       delete arg1;
68568     } catch (std::out_of_range& e) {
68569       {
68570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68571       };
68572     } catch (std::exception& e) {
68573       {
68574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68575       };
68576     } catch (Dali::DaliException e) {
68577       {
68578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68579       };
68580     } catch (...) {
68581       {
68582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68583       };
68584     }
68585   }
68586
68587 }
68588
68589
68590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68591   void * jresult ;
68592   Dali::BaseHandle arg1 ;
68593   Dali::BaseHandle *argp1 ;
68594   Dali::Toolkit::Alignment result;
68595
68596   argp1 = (Dali::BaseHandle *)jarg1;
68597   if (!argp1) {
68598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68599     return 0;
68600   }
68601   arg1 = *argp1;
68602   {
68603     try {
68604       result = Dali::Toolkit::Alignment::DownCast(arg1);
68605     } catch (std::out_of_range& e) {
68606       {
68607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68608       };
68609     } catch (std::exception& e) {
68610       {
68611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68612       };
68613     } catch (Dali::DaliException e) {
68614       {
68615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68616       };
68617     } catch (...) {
68618       {
68619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68620       };
68621     }
68622   }
68623
68624   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68625   return jresult;
68626 }
68627
68628
68629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68630   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68631   Dali::Toolkit::Alignment::Type arg2 ;
68632
68633   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68634   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68635   {
68636     try {
68637       (arg1)->SetAlignmentType(arg2);
68638     } catch (std::out_of_range& e) {
68639       {
68640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68641       };
68642     } catch (std::exception& e) {
68643       {
68644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68645       };
68646     } catch (Dali::DaliException e) {
68647       {
68648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68649       };
68650     } catch (...) {
68651       {
68652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68653       };
68654     }
68655   }
68656
68657 }
68658
68659
68660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68661   int jresult ;
68662   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68663   Dali::Toolkit::Alignment::Type result;
68664
68665   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68666   {
68667     try {
68668       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68669     } catch (std::out_of_range& e) {
68670       {
68671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68672       };
68673     } catch (std::exception& e) {
68674       {
68675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68676       };
68677     } catch (Dali::DaliException e) {
68678       {
68679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68680       };
68681     } catch (...) {
68682       {
68683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68684       };
68685     }
68686   }
68687
68688   jresult = (int)result;
68689   return jresult;
68690 }
68691
68692
68693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68694   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68695   Dali::Toolkit::Alignment::Scaling arg2 ;
68696
68697   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68698   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68699   {
68700     try {
68701       (arg1)->SetScaling(arg2);
68702     } catch (std::out_of_range& e) {
68703       {
68704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68705       };
68706     } catch (std::exception& e) {
68707       {
68708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68709       };
68710     } catch (Dali::DaliException e) {
68711       {
68712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68713       };
68714     } catch (...) {
68715       {
68716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68717       };
68718     }
68719   }
68720
68721 }
68722
68723
68724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68725   int jresult ;
68726   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68727   Dali::Toolkit::Alignment::Scaling result;
68728
68729   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68730   {
68731     try {
68732       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
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 = (int)result;
68753   return jresult;
68754 }
68755
68756
68757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68758   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68759   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68760
68761   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68762   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68763   if (!arg2) {
68764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68765     return ;
68766   }
68767   {
68768     try {
68769       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68770     } catch (std::out_of_range& e) {
68771       {
68772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68773       };
68774     } catch (std::exception& e) {
68775       {
68776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68777       };
68778     } catch (Dali::DaliException e) {
68779       {
68780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68781       };
68782     } catch (...) {
68783       {
68784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68785       };
68786     }
68787   }
68788
68789 }
68790
68791
68792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68793   void * jresult ;
68794   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68795   Dali::Toolkit::Alignment::Padding *result = 0 ;
68796
68797   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68798   {
68799     try {
68800       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68801     } catch (std::out_of_range& e) {
68802       {
68803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68804       };
68805     } catch (std::exception& e) {
68806       {
68807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68808       };
68809     } catch (Dali::DaliException e) {
68810       {
68811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68812       };
68813     } catch (...) {
68814       {
68815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68816       };
68817     }
68818   }
68819
68820   jresult = (void *)result;
68821   return jresult;
68822 }
68823
68824
68825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68826   void * jresult ;
68827   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68828   Dali::Toolkit::Alignment *arg2 = 0 ;
68829   Dali::Toolkit::Alignment *result = 0 ;
68830
68831   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68832   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68833   if (!arg2) {
68834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68835     return 0;
68836   }
68837   {
68838     try {
68839       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68840     } catch (std::out_of_range& e) {
68841       {
68842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68843       };
68844     } catch (std::exception& e) {
68845       {
68846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68847       };
68848     } catch (Dali::DaliException e) {
68849       {
68850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68851       };
68852     } catch (...) {
68853       {
68854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68855       };
68856     }
68857   }
68858
68859   jresult = (void *)result;
68860   return jresult;
68861 }
68862
68863
68864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68865   int jresult ;
68866   int result;
68867
68868   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68869   jresult = (int)result;
68870   return jresult;
68871 }
68872
68873
68874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68875   int jresult ;
68876   int result;
68877
68878   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68879   jresult = (int)result;
68880   return jresult;
68881 }
68882
68883
68884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68885   int jresult ;
68886   int result;
68887
68888   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68889   jresult = (int)result;
68890   return jresult;
68891 }
68892
68893
68894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68895   int jresult ;
68896   int result;
68897
68898   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68899   jresult = (int)result;
68900   return jresult;
68901 }
68902
68903
68904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68905   int jresult ;
68906   int result;
68907
68908   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
68909   jresult = (int)result;
68910   return jresult;
68911 }
68912
68913
68914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
68915   int jresult ;
68916   int result;
68917
68918   result = (int)Dali::Toolkit::Button::Property::SELECTED;
68919   jresult = (int)result;
68920   return jresult;
68921 }
68922
68923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
68924   int jresult ;
68925   int result;
68926
68927   result = (int)Dali::Toolkit::Button::Property::LABEL;
68928   jresult = (int)result;
68929   return jresult;
68930 }
68931
68932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
68933   void * jresult ;
68934   Dali::Toolkit::Button::Property *result = 0 ;
68935
68936   {
68937     try {
68938       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
68939     } catch (std::out_of_range& e) {
68940       {
68941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68942       };
68943     } catch (std::exception& e) {
68944       {
68945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68946       };
68947     } catch (Dali::DaliException e) {
68948       {
68949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68950       };
68951     } catch (...) {
68952       {
68953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68954       };
68955     }
68956   }
68957
68958   jresult = (void *)result;
68959   return jresult;
68960 }
68961
68962
68963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
68964   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
68965
68966   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
68967   {
68968     try {
68969       delete arg1;
68970     } catch (std::out_of_range& e) {
68971       {
68972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68973       };
68974     } catch (std::exception& e) {
68975       {
68976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68977       };
68978     } catch (Dali::DaliException e) {
68979       {
68980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68981       };
68982     } catch (...) {
68983       {
68984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68985       };
68986     }
68987   }
68988
68989 }
68990
68991
68992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
68993   void * jresult ;
68994   Dali::Toolkit::Button *result = 0 ;
68995
68996   {
68997     try {
68998       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
68999     } catch (std::out_of_range& e) {
69000       {
69001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69002       };
69003     } catch (std::exception& e) {
69004       {
69005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69006       };
69007     } catch (Dali::DaliException e) {
69008       {
69009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69010       };
69011     } catch (...) {
69012       {
69013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69014       };
69015     }
69016   }
69017
69018   jresult = (void *)result;
69019   return jresult;
69020 }
69021
69022
69023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69024   void * jresult ;
69025   Dali::Toolkit::Button *arg1 = 0 ;
69026   Dali::Toolkit::Button *result = 0 ;
69027
69028   arg1 = (Dali::Toolkit::Button *)jarg1;
69029   if (!arg1) {
69030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69031     return 0;
69032   }
69033   {
69034     try {
69035       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69036     } catch (std::out_of_range& e) {
69037       {
69038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69039       };
69040     } catch (std::exception& e) {
69041       {
69042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69043       };
69044     } catch (Dali::DaliException e) {
69045       {
69046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69047       };
69048     } catch (...) {
69049       {
69050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69051       };
69052     }
69053   }
69054
69055   jresult = (void *)result;
69056   return jresult;
69057 }
69058
69059
69060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69061   void * jresult ;
69062   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69063   Dali::Toolkit::Button *arg2 = 0 ;
69064   Dali::Toolkit::Button *result = 0 ;
69065
69066   arg1 = (Dali::Toolkit::Button *)jarg1;
69067   arg2 = (Dali::Toolkit::Button *)jarg2;
69068   if (!arg2) {
69069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69070     return 0;
69071   }
69072   {
69073     try {
69074       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69075     } catch (std::out_of_range& e) {
69076       {
69077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69078       };
69079     } catch (std::exception& e) {
69080       {
69081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69082       };
69083     } catch (Dali::DaliException e) {
69084       {
69085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69086       };
69087     } catch (...) {
69088       {
69089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69090       };
69091     }
69092   }
69093
69094   jresult = (void *)result;
69095   return jresult;
69096 }
69097
69098
69099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69100   void * jresult ;
69101   Dali::BaseHandle arg1 ;
69102   Dali::BaseHandle *argp1 ;
69103   Dali::Toolkit::Button result;
69104
69105   argp1 = (Dali::BaseHandle *)jarg1;
69106   if (!argp1) {
69107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69108     return 0;
69109   }
69110   arg1 = *argp1;
69111   {
69112     try {
69113       result = Dali::Toolkit::Button::DownCast(arg1);
69114     } catch (std::out_of_range& e) {
69115       {
69116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69117       };
69118     } catch (std::exception& e) {
69119       {
69120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69121       };
69122     } catch (Dali::DaliException e) {
69123       {
69124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69125       };
69126     } catch (...) {
69127       {
69128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69129       };
69130     }
69131   }
69132
69133   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69134   return jresult;
69135 }
69136
69137
69138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69139   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69140
69141   arg1 = (Dali::Toolkit::Button *)jarg1;
69142   {
69143     try {
69144       delete arg1;
69145     } catch (std::out_of_range& e) {
69146       {
69147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69148       };
69149     } catch (std::exception& e) {
69150       {
69151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69152       };
69153     } catch (Dali::DaliException e) {
69154       {
69155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69156       };
69157     } catch (...) {
69158       {
69159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69160       };
69161     }
69162   }
69163
69164 }
69165
69166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69167   void * jresult ;
69168   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69169   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69170
69171   arg1 = (Dali::Toolkit::Button *)jarg1;
69172   {
69173     try {
69174       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69175     } catch (std::out_of_range& e) {
69176       {
69177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69178       };
69179     } catch (std::exception& e) {
69180       {
69181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69182       };
69183     } catch (Dali::DaliException e) {
69184       {
69185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69186       };
69187     } catch (...) {
69188       {
69189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69190       };
69191     }
69192   }
69193
69194   jresult = (void *)result;
69195   return jresult;
69196 }
69197
69198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69199   void * jresult ;
69200   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69201   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69202
69203   arg1 = (Dali::Toolkit::Button *)jarg1;
69204   {
69205     try {
69206       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69207     } catch (std::out_of_range& e) {
69208       {
69209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69210       };
69211     } catch (std::exception& e) {
69212       {
69213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69214       };
69215     } catch (Dali::DaliException e) {
69216       {
69217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69218       };
69219     } catch (...) {
69220       {
69221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69222       };
69223     }
69224   }
69225
69226   jresult = (void *)result;
69227   return jresult;
69228 }
69229
69230
69231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69232   void * jresult ;
69233   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69234   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69235
69236   arg1 = (Dali::Toolkit::Button *)jarg1;
69237   {
69238     try {
69239       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69240     } catch (std::out_of_range& e) {
69241       {
69242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69243       };
69244     } catch (std::exception& e) {
69245       {
69246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69247       };
69248     } catch (Dali::DaliException e) {
69249       {
69250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69251       };
69252     } catch (...) {
69253       {
69254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69255       };
69256     }
69257   }
69258
69259   jresult = (void *)result;
69260   return jresult;
69261 }
69262
69263
69264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69265   void * jresult ;
69266   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69267   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69268
69269   arg1 = (Dali::Toolkit::Button *)jarg1;
69270   {
69271     try {
69272       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69273     } catch (std::out_of_range& e) {
69274       {
69275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69276       };
69277     } catch (std::exception& e) {
69278       {
69279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69280       };
69281     } catch (Dali::DaliException e) {
69282       {
69283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69284       };
69285     } catch (...) {
69286       {
69287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69288       };
69289     }
69290   }
69291
69292   jresult = (void *)result;
69293   return jresult;
69294 }
69295
69296
69297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69298   void * jresult ;
69299   Dali::Toolkit::CheckBoxButton *result = 0 ;
69300
69301   {
69302     try {
69303       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69304     } catch (std::out_of_range& e) {
69305       {
69306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69307       };
69308     } catch (std::exception& e) {
69309       {
69310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69311       };
69312     } catch (Dali::DaliException e) {
69313       {
69314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69315       };
69316     } catch (...) {
69317       {
69318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69319       };
69320     }
69321   }
69322
69323   jresult = (void *)result;
69324   return jresult;
69325 }
69326
69327
69328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69329   void * jresult ;
69330   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69331   Dali::Toolkit::CheckBoxButton *result = 0 ;
69332
69333   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69334   if (!arg1) {
69335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69336     return 0;
69337   }
69338   {
69339     try {
69340       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69341     } catch (std::out_of_range& e) {
69342       {
69343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69344       };
69345     } catch (std::exception& e) {
69346       {
69347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69348       };
69349     } catch (Dali::DaliException e) {
69350       {
69351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69352       };
69353     } catch (...) {
69354       {
69355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69356       };
69357     }
69358   }
69359
69360   jresult = (void *)result;
69361   return jresult;
69362 }
69363
69364
69365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69366   void * jresult ;
69367   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69368   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69369   Dali::Toolkit::CheckBoxButton *result = 0 ;
69370
69371   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69372   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69373   if (!arg2) {
69374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69375     return 0;
69376   }
69377   {
69378     try {
69379       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69380     } catch (std::out_of_range& e) {
69381       {
69382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69383       };
69384     } catch (std::exception& e) {
69385       {
69386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69387       };
69388     } catch (Dali::DaliException e) {
69389       {
69390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69391       };
69392     } catch (...) {
69393       {
69394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69395       };
69396     }
69397   }
69398
69399   jresult = (void *)result;
69400   return jresult;
69401 }
69402
69403
69404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69405   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69406
69407   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69408   {
69409     try {
69410       delete arg1;
69411     } catch (std::out_of_range& e) {
69412       {
69413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69414       };
69415     } catch (std::exception& e) {
69416       {
69417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69418       };
69419     } catch (Dali::DaliException e) {
69420       {
69421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69422       };
69423     } catch (...) {
69424       {
69425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69426       };
69427     }
69428   }
69429
69430 }
69431
69432
69433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69434   void * jresult ;
69435   Dali::Toolkit::CheckBoxButton result;
69436
69437   {
69438     try {
69439       result = Dali::Toolkit::CheckBoxButton::New();
69440     } catch (std::out_of_range& e) {
69441       {
69442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69443       };
69444     } catch (std::exception& e) {
69445       {
69446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69447       };
69448     } catch (Dali::DaliException e) {
69449       {
69450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69451       };
69452     } catch (...) {
69453       {
69454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69455       };
69456     }
69457   }
69458
69459   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69460   return jresult;
69461 }
69462
69463
69464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
69465   void * jresult ;
69466   Dali::BaseHandle arg1 ;
69467   Dali::BaseHandle *argp1 ;
69468   Dali::Toolkit::CheckBoxButton result;
69469
69470   argp1 = (Dali::BaseHandle *)jarg1;
69471   if (!argp1) {
69472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69473     return 0;
69474   }
69475   arg1 = *argp1;
69476   {
69477     try {
69478       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
69479     } catch (std::out_of_range& e) {
69480       {
69481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69482       };
69483     } catch (std::exception& e) {
69484       {
69485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69486       };
69487     } catch (Dali::DaliException e) {
69488       {
69489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69490       };
69491     } catch (...) {
69492       {
69493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69494       };
69495     }
69496   }
69497
69498   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
69499   return jresult;
69500 }
69501
69502
69503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
69504   int jresult ;
69505   int result;
69506
69507   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
69508   jresult = (int)result;
69509   return jresult;
69510 }
69511
69512
69513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
69514   int jresult ;
69515   int result;
69516
69517   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
69518   jresult = (int)result;
69519   return jresult;
69520 }
69521
69522
69523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
69524   int jresult ;
69525   int result;
69526
69527   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
69528   jresult = (int)result;
69529   return jresult;
69530 }
69531
69532
69533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
69534   int jresult ;
69535   int result;
69536
69537   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
69538   jresult = (int)result;
69539   return jresult;
69540 }
69541
69542
69543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
69544   int jresult ;
69545   int result;
69546
69547   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
69548   jresult = (int)result;
69549   return jresult;
69550 }
69551
69552
69553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
69554   void * jresult ;
69555   Dali::Toolkit::PushButton::Property *result = 0 ;
69556
69557   {
69558     try {
69559       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
69560     } catch (std::out_of_range& e) {
69561       {
69562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69563       };
69564     } catch (std::exception& e) {
69565       {
69566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69567       };
69568     } catch (Dali::DaliException e) {
69569       {
69570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69571       };
69572     } catch (...) {
69573       {
69574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69575       };
69576     }
69577   }
69578
69579   jresult = (void *)result;
69580   return jresult;
69581 }
69582
69583
69584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
69585   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
69586
69587   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
69588   {
69589     try {
69590       delete arg1;
69591     } catch (std::out_of_range& e) {
69592       {
69593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69594       };
69595     } catch (std::exception& e) {
69596       {
69597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69598       };
69599     } catch (Dali::DaliException e) {
69600       {
69601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69602       };
69603     } catch (...) {
69604       {
69605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69606       };
69607     }
69608   }
69609
69610 }
69611
69612
69613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
69614   void * jresult ;
69615   Dali::Toolkit::PushButton *result = 0 ;
69616
69617   {
69618     try {
69619       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
69620     } catch (std::out_of_range& e) {
69621       {
69622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69623       };
69624     } catch (std::exception& e) {
69625       {
69626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69627       };
69628     } catch (Dali::DaliException e) {
69629       {
69630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69631       };
69632     } catch (...) {
69633       {
69634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69635       };
69636     }
69637   }
69638
69639   jresult = (void *)result;
69640   return jresult;
69641 }
69642
69643
69644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
69645   void * jresult ;
69646   Dali::Toolkit::PushButton *arg1 = 0 ;
69647   Dali::Toolkit::PushButton *result = 0 ;
69648
69649   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69650   if (!arg1) {
69651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69652     return 0;
69653   }
69654   {
69655     try {
69656       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
69657     } catch (std::out_of_range& e) {
69658       {
69659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69660       };
69661     } catch (std::exception& e) {
69662       {
69663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69664       };
69665     } catch (Dali::DaliException e) {
69666       {
69667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69668       };
69669     } catch (...) {
69670       {
69671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69672       };
69673     }
69674   }
69675
69676   jresult = (void *)result;
69677   return jresult;
69678 }
69679
69680
69681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
69682   void * jresult ;
69683   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69684   Dali::Toolkit::PushButton *arg2 = 0 ;
69685   Dali::Toolkit::PushButton *result = 0 ;
69686
69687   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69688   arg2 = (Dali::Toolkit::PushButton *)jarg2;
69689   if (!arg2) {
69690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
69691     return 0;
69692   }
69693   {
69694     try {
69695       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
69696     } catch (std::out_of_range& e) {
69697       {
69698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69699       };
69700     } catch (std::exception& e) {
69701       {
69702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69703       };
69704     } catch (Dali::DaliException e) {
69705       {
69706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69707       };
69708     } catch (...) {
69709       {
69710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69711       };
69712     }
69713   }
69714
69715   jresult = (void *)result;
69716   return jresult;
69717 }
69718
69719
69720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
69721   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
69722
69723   arg1 = (Dali::Toolkit::PushButton *)jarg1;
69724   {
69725     try {
69726       delete arg1;
69727     } catch (std::out_of_range& e) {
69728       {
69729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69730       };
69731     } catch (std::exception& e) {
69732       {
69733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69734       };
69735     } catch (Dali::DaliException e) {
69736       {
69737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69738       };
69739     } catch (...) {
69740       {
69741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69742       };
69743     }
69744   }
69745
69746 }
69747
69748
69749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
69750   void * jresult ;
69751   Dali::Toolkit::PushButton result;
69752
69753   {
69754     try {
69755       result = Dali::Toolkit::PushButton::New();
69756     } catch (std::out_of_range& e) {
69757       {
69758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69759       };
69760     } catch (std::exception& e) {
69761       {
69762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69763       };
69764     } catch (Dali::DaliException e) {
69765       {
69766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69767       };
69768     } catch (...) {
69769       {
69770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69771       };
69772     }
69773   }
69774
69775   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69776   return jresult;
69777 }
69778
69779
69780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
69781   void * jresult ;
69782   Dali::BaseHandle arg1 ;
69783   Dali::BaseHandle *argp1 ;
69784   Dali::Toolkit::PushButton result;
69785
69786   argp1 = (Dali::BaseHandle *)jarg1;
69787   if (!argp1) {
69788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69789     return 0;
69790   }
69791   arg1 = *argp1;
69792   {
69793     try {
69794       result = Dali::Toolkit::PushButton::DownCast(arg1);
69795     } catch (std::out_of_range& e) {
69796       {
69797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69798       };
69799     } catch (std::exception& e) {
69800       {
69801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69802       };
69803     } catch (Dali::DaliException e) {
69804       {
69805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69806       };
69807     } catch (...) {
69808       {
69809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69810       };
69811     }
69812   }
69813
69814   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
69815   return jresult;
69816 }
69817
69818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
69819   void * jresult ;
69820   Dali::Toolkit::RadioButton *result = 0 ;
69821
69822   {
69823     try {
69824       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
69825     } catch (std::out_of_range& e) {
69826       {
69827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69828       };
69829     } catch (std::exception& e) {
69830       {
69831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69832       };
69833     } catch (Dali::DaliException e) {
69834       {
69835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69836       };
69837     } catch (...) {
69838       {
69839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69840       };
69841     }
69842   }
69843
69844   jresult = (void *)result;
69845   return jresult;
69846 }
69847
69848
69849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
69850   void * jresult ;
69851   Dali::Toolkit::RadioButton *arg1 = 0 ;
69852   Dali::Toolkit::RadioButton *result = 0 ;
69853
69854   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69855   if (!arg1) {
69856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69857     return 0;
69858   }
69859   {
69860     try {
69861       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
69862     } catch (std::out_of_range& e) {
69863       {
69864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69865       };
69866     } catch (std::exception& e) {
69867       {
69868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69869       };
69870     } catch (Dali::DaliException e) {
69871       {
69872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69873       };
69874     } catch (...) {
69875       {
69876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69877       };
69878     }
69879   }
69880
69881   jresult = (void *)result;
69882   return jresult;
69883 }
69884
69885
69886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
69887   void * jresult ;
69888   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69889   Dali::Toolkit::RadioButton *arg2 = 0 ;
69890   Dali::Toolkit::RadioButton *result = 0 ;
69891
69892   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69893   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
69894   if (!arg2) {
69895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
69896     return 0;
69897   }
69898   {
69899     try {
69900       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
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 = (void *)result;
69921   return jresult;
69922 }
69923
69924
69925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
69926   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
69927
69928   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
69929   {
69930     try {
69931       delete arg1;
69932     } catch (std::out_of_range& e) {
69933       {
69934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69935       };
69936     } catch (std::exception& e) {
69937       {
69938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69939       };
69940     } catch (Dali::DaliException e) {
69941       {
69942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69943       };
69944     } catch (...) {
69945       {
69946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69947       };
69948     }
69949   }
69950
69951 }
69952
69953
69954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
69955   void * jresult ;
69956   Dali::Toolkit::RadioButton result;
69957
69958   {
69959     try {
69960       result = Dali::Toolkit::RadioButton::New();
69961     } catch (std::out_of_range& e) {
69962       {
69963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69964       };
69965     } catch (std::exception& e) {
69966       {
69967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69968       };
69969     } catch (Dali::DaliException e) {
69970       {
69971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69972       };
69973     } catch (...) {
69974       {
69975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69976       };
69977     }
69978   }
69979
69980   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
69981   return jresult;
69982 }
69983
69984
69985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
69986   void * jresult ;
69987   std::string *arg1 = 0 ;
69988   Dali::Toolkit::RadioButton result;
69989
69990   if (!jarg1) {
69991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69992     return 0;
69993   }
69994   std::string arg1_str(jarg1);
69995   arg1 = &arg1_str;
69996   {
69997     try {
69998       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
69999     } catch (std::out_of_range& e) {
70000       {
70001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70002       };
70003     } catch (std::exception& e) {
70004       {
70005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70006       };
70007     } catch (Dali::DaliException e) {
70008       {
70009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70010       };
70011     } catch (...) {
70012       {
70013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70014       };
70015     }
70016   }
70017
70018   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70019
70020   //argout typemap for const std::string&
70021
70022   return jresult;
70023 }
70024
70025
70026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70027   void * jresult ;
70028   Dali::BaseHandle arg1 ;
70029   Dali::BaseHandle *argp1 ;
70030   Dali::Toolkit::RadioButton result;
70031
70032   argp1 = (Dali::BaseHandle *)jarg1;
70033   if (!argp1) {
70034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70035     return 0;
70036   }
70037   arg1 = *argp1;
70038   {
70039     try {
70040       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70041     } catch (std::out_of_range& e) {
70042       {
70043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70044       };
70045     } catch (std::exception& e) {
70046       {
70047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70048       };
70049     } catch (Dali::DaliException e) {
70050       {
70051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70052       };
70053     } catch (...) {
70054       {
70055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70056       };
70057     }
70058   }
70059
70060   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70061   return jresult;
70062 }
70063
70064
70065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70066   int jresult ;
70067   int result;
70068
70069   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70070   jresult = (int)result;
70071   return jresult;
70072 }
70073
70074
70075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70076   int jresult ;
70077   int result;
70078
70079   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
70080   jresult = (int)result;
70081   return jresult;
70082 }
70083
70084
70085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
70086   int jresult ;
70087   int result;
70088
70089   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
70090   jresult = (int)result;
70091   return jresult;
70092 }
70093
70094
70095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
70096   int jresult ;
70097   int result;
70098
70099   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
70100   jresult = (int)result;
70101   return jresult;
70102 }
70103
70104
70105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
70106   int jresult ;
70107   int result;
70108
70109   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
70110   jresult = (int)result;
70111   return jresult;
70112 }
70113
70114
70115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
70116   int jresult ;
70117   int result;
70118
70119   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
70120   jresult = (int)result;
70121   return jresult;
70122 }
70123
70124
70125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
70126   void * jresult ;
70127   Dali::Toolkit::FlexContainer::Property *result = 0 ;
70128
70129   {
70130     try {
70131       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
70132     } catch (std::out_of_range& e) {
70133       {
70134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70135       };
70136     } catch (std::exception& e) {
70137       {
70138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70139       };
70140     } catch (Dali::DaliException e) {
70141       {
70142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70143       };
70144     } catch (...) {
70145       {
70146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70147       };
70148     }
70149   }
70150
70151   jresult = (void *)result;
70152   return jresult;
70153 }
70154
70155
70156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
70157   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
70158
70159   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
70160   {
70161     try {
70162       delete arg1;
70163     } catch (std::out_of_range& e) {
70164       {
70165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70166       };
70167     } catch (std::exception& e) {
70168       {
70169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70170       };
70171     } catch (Dali::DaliException e) {
70172       {
70173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70174       };
70175     } catch (...) {
70176       {
70177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70178       };
70179     }
70180   }
70181
70182 }
70183
70184
70185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
70186   int jresult ;
70187   int result;
70188
70189   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
70190   jresult = (int)result;
70191   return jresult;
70192 }
70193
70194
70195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
70196   int jresult ;
70197   int result;
70198
70199   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
70200   jresult = (int)result;
70201   return jresult;
70202 }
70203
70204
70205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
70206   int jresult ;
70207   int result;
70208
70209   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
70210   jresult = (int)result;
70211   return jresult;
70212 }
70213
70214
70215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
70216   void * jresult ;
70217   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
70218
70219   {
70220     try {
70221       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
70222     } catch (std::out_of_range& e) {
70223       {
70224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70225       };
70226     } catch (std::exception& e) {
70227       {
70228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70229       };
70230     } catch (Dali::DaliException e) {
70231       {
70232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70233       };
70234     } catch (...) {
70235       {
70236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70237       };
70238     }
70239   }
70240
70241   jresult = (void *)result;
70242   return jresult;
70243 }
70244
70245
70246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
70247   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
70248
70249   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
70250   {
70251     try {
70252       delete arg1;
70253     } catch (std::out_of_range& e) {
70254       {
70255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70256       };
70257     } catch (std::exception& e) {
70258       {
70259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70260       };
70261     } catch (Dali::DaliException e) {
70262       {
70263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70264       };
70265     } catch (...) {
70266       {
70267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70268       };
70269     }
70270   }
70271
70272 }
70273
70274
70275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
70276   void * jresult ;
70277   Dali::Toolkit::FlexContainer *result = 0 ;
70278
70279   {
70280     try {
70281       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
70282     } catch (std::out_of_range& e) {
70283       {
70284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70285       };
70286     } catch (std::exception& e) {
70287       {
70288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70289       };
70290     } catch (Dali::DaliException e) {
70291       {
70292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70293       };
70294     } catch (...) {
70295       {
70296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70297       };
70298     }
70299   }
70300
70301   jresult = (void *)result;
70302   return jresult;
70303 }
70304
70305
70306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
70307   void * jresult ;
70308   Dali::Toolkit::FlexContainer *arg1 = 0 ;
70309   Dali::Toolkit::FlexContainer *result = 0 ;
70310
70311   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70312   if (!arg1) {
70313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70314     return 0;
70315   }
70316   {
70317     try {
70318       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
70319     } catch (std::out_of_range& e) {
70320       {
70321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70322       };
70323     } catch (std::exception& e) {
70324       {
70325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70326       };
70327     } catch (Dali::DaliException e) {
70328       {
70329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70330       };
70331     } catch (...) {
70332       {
70333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70334       };
70335     }
70336   }
70337
70338   jresult = (void *)result;
70339   return jresult;
70340 }
70341
70342
70343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
70344   void * jresult ;
70345   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70346   Dali::Toolkit::FlexContainer *arg2 = 0 ;
70347   Dali::Toolkit::FlexContainer *result = 0 ;
70348
70349   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70350   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
70351   if (!arg2) {
70352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
70353     return 0;
70354   }
70355   {
70356     try {
70357       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
70358     } catch (std::out_of_range& e) {
70359       {
70360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70361       };
70362     } catch (std::exception& e) {
70363       {
70364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70365       };
70366     } catch (Dali::DaliException e) {
70367       {
70368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70369       };
70370     } catch (...) {
70371       {
70372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70373       };
70374     }
70375   }
70376
70377   jresult = (void *)result;
70378   return jresult;
70379 }
70380
70381
70382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
70383   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
70384
70385   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
70386   {
70387     try {
70388       delete arg1;
70389     } catch (std::out_of_range& e) {
70390       {
70391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70392       };
70393     } catch (std::exception& e) {
70394       {
70395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70396       };
70397     } catch (Dali::DaliException e) {
70398       {
70399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70400       };
70401     } catch (...) {
70402       {
70403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70404       };
70405     }
70406   }
70407
70408 }
70409
70410
70411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
70412   void * jresult ;
70413   Dali::Toolkit::FlexContainer result;
70414
70415   {
70416     try {
70417       result = Dali::Toolkit::FlexContainer::New();
70418     } catch (std::out_of_range& e) {
70419       {
70420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70421       };
70422     } catch (std::exception& e) {
70423       {
70424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70425       };
70426     } catch (Dali::DaliException e) {
70427       {
70428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70429       };
70430     } catch (...) {
70431       {
70432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70433       };
70434     }
70435   }
70436
70437   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70438   return jresult;
70439 }
70440
70441
70442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
70443   void * jresult ;
70444   Dali::BaseHandle arg1 ;
70445   Dali::BaseHandle *argp1 ;
70446   Dali::Toolkit::FlexContainer result;
70447
70448   argp1 = (Dali::BaseHandle *)jarg1;
70449   if (!argp1) {
70450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70451     return 0;
70452   }
70453   arg1 = *argp1;
70454   {
70455     try {
70456       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
70457     } catch (std::out_of_range& e) {
70458       {
70459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70460       };
70461     } catch (std::exception& e) {
70462       {
70463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70464       };
70465     } catch (Dali::DaliException e) {
70466       {
70467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70468       };
70469     } catch (...) {
70470       {
70471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70472       };
70473     }
70474   }
70475
70476   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
70477   return jresult;
70478 }
70479
70480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
70481   int jresult ;
70482   int result;
70483
70484   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
70485   jresult = (int)result;
70486   return jresult;
70487 }
70488
70489
70490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
70491   int jresult ;
70492   int result;
70493
70494   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
70495   jresult = (int)result;
70496   return jresult;
70497 }
70498
70499
70500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
70501   int jresult ;
70502   int result;
70503
70504   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
70505   jresult = (int)result;
70506   return jresult;
70507 }
70508
70509
70510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
70511   void * jresult ;
70512   Dali::Toolkit::ImageView::Property *result = 0 ;
70513
70514   {
70515     try {
70516       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
70517     } catch (std::out_of_range& e) {
70518       {
70519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70520       };
70521     } catch (std::exception& e) {
70522       {
70523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70524       };
70525     } catch (Dali::DaliException e) {
70526       {
70527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70528       };
70529     } catch (...) {
70530       {
70531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70532       };
70533     }
70534   }
70535
70536   jresult = (void *)result;
70537   return jresult;
70538 }
70539
70540
70541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
70542   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
70543
70544   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
70545   {
70546     try {
70547       delete arg1;
70548     } catch (std::out_of_range& e) {
70549       {
70550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70551       };
70552     } catch (std::exception& e) {
70553       {
70554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70555       };
70556     } catch (Dali::DaliException e) {
70557       {
70558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70559       };
70560     } catch (...) {
70561       {
70562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70563       };
70564     }
70565   }
70566
70567 }
70568
70569
70570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
70571   void * jresult ;
70572   Dali::Toolkit::ImageView *result = 0 ;
70573
70574   {
70575     try {
70576       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
70577     } catch (std::out_of_range& e) {
70578       {
70579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70580       };
70581     } catch (std::exception& e) {
70582       {
70583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70584       };
70585     } catch (Dali::DaliException e) {
70586       {
70587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70588       };
70589     } catch (...) {
70590       {
70591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70592       };
70593     }
70594   }
70595
70596   jresult = (void *)result;
70597   return jresult;
70598 }
70599
70600
70601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
70602   void * jresult ;
70603   Dali::Toolkit::ImageView result;
70604
70605   {
70606     try {
70607       result = Dali::Toolkit::ImageView::New();
70608     } catch (std::out_of_range& e) {
70609       {
70610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70611       };
70612     } catch (std::exception& e) {
70613       {
70614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70615       };
70616     } catch (Dali::DaliException e) {
70617       {
70618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70619       };
70620     } catch (...) {
70621       {
70622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70623       };
70624     }
70625   }
70626
70627   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70628   return jresult;
70629 }
70630
70631
70632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
70633   void * jresult ;
70634   Dali::Image arg1 ;
70635   Dali::Image *argp1 ;
70636   Dali::Toolkit::ImageView result;
70637
70638   argp1 = (Dali::Image *)jarg1;
70639   if (!argp1) {
70640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70641     return 0;
70642   }
70643   arg1 = *argp1;
70644   {
70645     try {
70646       result = Dali::Toolkit::ImageView::New(arg1);
70647     } catch (std::out_of_range& e) {
70648       {
70649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70650       };
70651     } catch (std::exception& e) {
70652       {
70653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70654       };
70655     } catch (Dali::DaliException e) {
70656       {
70657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70658       };
70659     } catch (...) {
70660       {
70661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70662       };
70663     }
70664   }
70665
70666   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70667   return jresult;
70668 }
70669
70670
70671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
70672   void * jresult ;
70673   std::string *arg1 = 0 ;
70674   Dali::Toolkit::ImageView result;
70675
70676   if (!jarg1) {
70677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70678     return 0;
70679   }
70680   std::string arg1_str(jarg1);
70681   arg1 = &arg1_str;
70682   {
70683     try {
70684       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
70685     } catch (std::out_of_range& e) {
70686       {
70687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70688       };
70689     } catch (std::exception& e) {
70690       {
70691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70692       };
70693     } catch (Dali::DaliException e) {
70694       {
70695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70696       };
70697     } catch (...) {
70698       {
70699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70700       };
70701     }
70702   }
70703
70704   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70705
70706   //argout typemap for const std::string&
70707
70708   return jresult;
70709 }
70710
70711
70712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
70713   void * jresult ;
70714   std::string *arg1 = 0 ;
70715   Dali::ImageDimensions arg2 ;
70716   Dali::ImageDimensions *argp2 ;
70717   Dali::Toolkit::ImageView result;
70718
70719   if (!jarg1) {
70720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70721     return 0;
70722   }
70723   std::string arg1_str(jarg1);
70724   arg1 = &arg1_str;
70725   argp2 = (Dali::ImageDimensions *)jarg2;
70726   if (!argp2) {
70727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70728     return 0;
70729   }
70730   arg2 = *argp2;
70731   {
70732     try {
70733       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
70734     } catch (std::out_of_range& e) {
70735       {
70736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70737       };
70738     } catch (std::exception& e) {
70739       {
70740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70741       };
70742     } catch (Dali::DaliException e) {
70743       {
70744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70745       };
70746     } catch (...) {
70747       {
70748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70749       };
70750     }
70751   }
70752
70753   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70754
70755   //argout typemap for const std::string&
70756
70757   return jresult;
70758 }
70759
70760
70761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
70762   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70763
70764   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70765   {
70766     try {
70767       delete arg1;
70768     } catch (std::out_of_range& e) {
70769       {
70770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70771       };
70772     } catch (std::exception& e) {
70773       {
70774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70775       };
70776     } catch (Dali::DaliException e) {
70777       {
70778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70779       };
70780     } catch (...) {
70781       {
70782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70783       };
70784     }
70785   }
70786
70787 }
70788
70789
70790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
70791   void * jresult ;
70792   Dali::Toolkit::ImageView *arg1 = 0 ;
70793   Dali::Toolkit::ImageView *result = 0 ;
70794
70795   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70796   if (!arg1) {
70797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70798     return 0;
70799   }
70800   {
70801     try {
70802       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
70803     } catch (std::out_of_range& e) {
70804       {
70805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70806       };
70807     } catch (std::exception& e) {
70808       {
70809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70810       };
70811     } catch (Dali::DaliException e) {
70812       {
70813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70814       };
70815     } catch (...) {
70816       {
70817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70818       };
70819     }
70820   }
70821
70822   jresult = (void *)result;
70823   return jresult;
70824 }
70825
70826
70827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
70828   void * jresult ;
70829   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70830   Dali::Toolkit::ImageView *arg2 = 0 ;
70831   Dali::Toolkit::ImageView *result = 0 ;
70832
70833   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70834   arg2 = (Dali::Toolkit::ImageView *)jarg2;
70835   if (!arg2) {
70836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
70837     return 0;
70838   }
70839   {
70840     try {
70841       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
70842     } catch (std::out_of_range& e) {
70843       {
70844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70845       };
70846     } catch (std::exception& e) {
70847       {
70848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70849       };
70850     } catch (Dali::DaliException e) {
70851       {
70852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70853       };
70854     } catch (...) {
70855       {
70856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70857       };
70858     }
70859   }
70860
70861   jresult = (void *)result;
70862   return jresult;
70863 }
70864
70865
70866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
70867   void * jresult ;
70868   Dali::BaseHandle arg1 ;
70869   Dali::BaseHandle *argp1 ;
70870   Dali::Toolkit::ImageView result;
70871
70872   argp1 = (Dali::BaseHandle *)jarg1;
70873   if (!argp1) {
70874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70875     return 0;
70876   }
70877   arg1 = *argp1;
70878   {
70879     try {
70880       result = Dali::Toolkit::ImageView::DownCast(arg1);
70881     } catch (std::out_of_range& e) {
70882       {
70883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70884       };
70885     } catch (std::exception& e) {
70886       {
70887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70888       };
70889     } catch (Dali::DaliException e) {
70890       {
70891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70892       };
70893     } catch (...) {
70894       {
70895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70896       };
70897     }
70898   }
70899
70900   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
70901   return jresult;
70902 }
70903
70904
70905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
70906   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70907   Dali::Image arg2 ;
70908   Dali::Image *argp2 ;
70909
70910   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70911   argp2 = (Dali::Image *)jarg2;
70912   if (!argp2) {
70913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70914     return ;
70915   }
70916   arg2 = *argp2;
70917   {
70918     try {
70919       (arg1)->SetImage(arg2);
70920     } catch (std::out_of_range& e) {
70921       {
70922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70923       };
70924     } catch (std::exception& e) {
70925       {
70926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70927       };
70928     } catch (Dali::DaliException e) {
70929       {
70930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70931       };
70932     } catch (...) {
70933       {
70934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70935       };
70936     }
70937   }
70938
70939 }
70940
70941
70942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
70943   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70944   std::string *arg2 = 0 ;
70945
70946   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70947   if (!jarg2) {
70948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70949     return ;
70950   }
70951   std::string arg2_str(jarg2);
70952   arg2 = &arg2_str;
70953   {
70954     try {
70955       (arg1)->SetImage((std::string const &)*arg2);
70956     } catch (std::out_of_range& e) {
70957       {
70958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70959       };
70960     } catch (std::exception& e) {
70961       {
70962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70963       };
70964     } catch (Dali::DaliException e) {
70965       {
70966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70967       };
70968     } catch (...) {
70969       {
70970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70971       };
70972     }
70973   }
70974
70975
70976   //argout typemap for const std::string&
70977
70978 }
70979
70980
70981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
70982   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
70983   std::string *arg2 = 0 ;
70984   Dali::ImageDimensions arg3 ;
70985   Dali::ImageDimensions *argp3 ;
70986
70987   arg1 = (Dali::Toolkit::ImageView *)jarg1;
70988   if (!jarg2) {
70989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70990     return ;
70991   }
70992   std::string arg2_str(jarg2);
70993   arg2 = &arg2_str;
70994   argp3 = (Dali::ImageDimensions *)jarg3;
70995   if (!argp3) {
70996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
70997     return ;
70998   }
70999   arg3 = *argp3;
71000   {
71001     try {
71002       (arg1)->SetImage((std::string const &)*arg2,arg3);
71003     } catch (std::out_of_range& e) {
71004       {
71005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71006       };
71007     } catch (std::exception& e) {
71008       {
71009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71010       };
71011     } catch (Dali::DaliException e) {
71012       {
71013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71014       };
71015     } catch (...) {
71016       {
71017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71018       };
71019     }
71020   }
71021
71022
71023   //argout typemap for const std::string&
71024
71025 }
71026
71027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71028   void * jresult ;
71029   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71030   Dali::Image result;
71031
71032   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71033   {
71034     try {
71035       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71036     } catch (std::out_of_range& e) {
71037       {
71038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71039       };
71040     } catch (std::exception& e) {
71041       {
71042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71043       };
71044     } catch (Dali::DaliException e) {
71045       {
71046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71047       };
71048     } catch (...) {
71049       {
71050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71051       };
71052     }
71053   }
71054
71055   jresult = new Dali::Image((const Dali::Image &)result);
71056   return jresult;
71057 }
71058
71059
71060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71061   int jresult ;
71062   int result;
71063
71064   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71065   jresult = (int)result;
71066   return jresult;
71067 }
71068
71069
71070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
71071   int jresult ;
71072   int result;
71073
71074   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
71075   jresult = (int)result;
71076   return jresult;
71077 }
71078
71079
71080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
71081   int jresult ;
71082   int result;
71083
71084   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
71085   jresult = (int)result;
71086   return jresult;
71087 }
71088
71089
71090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
71091   int jresult ;
71092   int result;
71093
71094   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
71095   jresult = (int)result;
71096   return jresult;
71097 }
71098
71099
71100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
71101   int jresult ;
71102   int result;
71103
71104   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
71105   jresult = (int)result;
71106   return jresult;
71107 }
71108
71109
71110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
71111   int jresult ;
71112   int result;
71113
71114   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
71115   jresult = (int)result;
71116   return jresult;
71117 }
71118
71119
71120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
71121   int jresult ;
71122   int result;
71123
71124   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
71125   jresult = (int)result;
71126   return jresult;
71127 }
71128
71129
71130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
71131   int jresult ;
71132   int result;
71133
71134   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
71135   jresult = (int)result;
71136   return jresult;
71137 }
71138
71139
71140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
71141   void * jresult ;
71142   Dali::Toolkit::Model3dView::Property *result = 0 ;
71143
71144   {
71145     try {
71146       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
71147     } catch (std::out_of_range& e) {
71148       {
71149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71150       };
71151     } catch (std::exception& e) {
71152       {
71153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71154       };
71155     } catch (Dali::DaliException e) {
71156       {
71157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71158       };
71159     } catch (...) {
71160       {
71161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71162       };
71163     }
71164   }
71165
71166   jresult = (void *)result;
71167   return jresult;
71168 }
71169
71170
71171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
71172   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
71173
71174   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
71175   {
71176     try {
71177       delete arg1;
71178     } catch (std::out_of_range& e) {
71179       {
71180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71181       };
71182     } catch (std::exception& e) {
71183       {
71184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71185       };
71186     } catch (Dali::DaliException e) {
71187       {
71188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71189       };
71190     } catch (...) {
71191       {
71192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71193       };
71194     }
71195   }
71196
71197 }
71198
71199
71200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
71201   void * jresult ;
71202   Dali::Toolkit::Model3dView result;
71203
71204   {
71205     try {
71206       result = Dali::Toolkit::Model3dView::New();
71207     } catch (std::out_of_range& e) {
71208       {
71209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71210       };
71211     } catch (std::exception& e) {
71212       {
71213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71214       };
71215     } catch (Dali::DaliException e) {
71216       {
71217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71218       };
71219     } catch (...) {
71220       {
71221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71222       };
71223     }
71224   }
71225
71226   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71227   return jresult;
71228 }
71229
71230
71231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
71232   void * jresult ;
71233   std::string *arg1 = 0 ;
71234   std::string *arg2 = 0 ;
71235   std::string *arg3 = 0 ;
71236   Dali::Toolkit::Model3dView result;
71237
71238   if (!jarg1) {
71239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71240     return 0;
71241   }
71242   std::string arg1_str(jarg1);
71243   arg1 = &arg1_str;
71244   if (!jarg2) {
71245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71246     return 0;
71247   }
71248   std::string arg2_str(jarg2);
71249   arg2 = &arg2_str;
71250   if (!jarg3) {
71251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71252     return 0;
71253   }
71254   std::string arg3_str(jarg3);
71255   arg3 = &arg3_str;
71256   {
71257     try {
71258       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
71259     } catch (std::out_of_range& e) {
71260       {
71261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71262       };
71263     } catch (std::exception& e) {
71264       {
71265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71266       };
71267     } catch (Dali::DaliException e) {
71268       {
71269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71270       };
71271     } catch (...) {
71272       {
71273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71274       };
71275     }
71276   }
71277
71278   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71279
71280   //argout typemap for const std::string&
71281
71282
71283   //argout typemap for const std::string&
71284
71285
71286   //argout typemap for const std::string&
71287
71288   return jresult;
71289 }
71290
71291
71292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
71293   void * jresult ;
71294   Dali::Toolkit::Model3dView *result = 0 ;
71295
71296   {
71297     try {
71298       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
71299     } catch (std::out_of_range& e) {
71300       {
71301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71302       };
71303     } catch (std::exception& e) {
71304       {
71305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71306       };
71307     } catch (Dali::DaliException e) {
71308       {
71309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71310       };
71311     } catch (...) {
71312       {
71313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71314       };
71315     }
71316   }
71317
71318   jresult = (void *)result;
71319   return jresult;
71320 }
71321
71322
71323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
71324   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71325
71326   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71327   {
71328     try {
71329       delete arg1;
71330     } catch (std::out_of_range& e) {
71331       {
71332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71333       };
71334     } catch (std::exception& e) {
71335       {
71336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71337       };
71338     } catch (Dali::DaliException e) {
71339       {
71340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71341       };
71342     } catch (...) {
71343       {
71344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71345       };
71346     }
71347   }
71348
71349 }
71350
71351
71352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
71353   void * jresult ;
71354   Dali::Toolkit::Model3dView *arg1 = 0 ;
71355   Dali::Toolkit::Model3dView *result = 0 ;
71356
71357   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71358   if (!arg1) {
71359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71360     return 0;
71361   }
71362   {
71363     try {
71364       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
71365     } catch (std::out_of_range& e) {
71366       {
71367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71368       };
71369     } catch (std::exception& e) {
71370       {
71371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71372       };
71373     } catch (Dali::DaliException e) {
71374       {
71375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71376       };
71377     } catch (...) {
71378       {
71379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71380       };
71381     }
71382   }
71383
71384   jresult = (void *)result;
71385   return jresult;
71386 }
71387
71388
71389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
71390   void * jresult ;
71391   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
71392   Dali::Toolkit::Model3dView *arg2 = 0 ;
71393   Dali::Toolkit::Model3dView *result = 0 ;
71394
71395   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
71396   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
71397   if (!arg2) {
71398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
71399     return 0;
71400   }
71401   {
71402     try {
71403       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
71404     } catch (std::out_of_range& e) {
71405       {
71406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71407       };
71408     } catch (std::exception& e) {
71409       {
71410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71411       };
71412     } catch (Dali::DaliException e) {
71413       {
71414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71415       };
71416     } catch (...) {
71417       {
71418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71419       };
71420     }
71421   }
71422
71423   jresult = (void *)result;
71424   return jresult;
71425 }
71426
71427
71428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
71429   void * jresult ;
71430   Dali::BaseHandle arg1 ;
71431   Dali::BaseHandle *argp1 ;
71432   Dali::Toolkit::Model3dView result;
71433
71434   argp1 = (Dali::BaseHandle *)jarg1;
71435   if (!argp1) {
71436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71437     return 0;
71438   }
71439   arg1 = *argp1;
71440   {
71441     try {
71442       result = Dali::Toolkit::Model3dView::DownCast(arg1);
71443     } catch (std::out_of_range& e) {
71444       {
71445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71446       };
71447     } catch (std::exception& e) {
71448       {
71449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71450       };
71451     } catch (Dali::DaliException e) {
71452       {
71453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71454       };
71455     } catch (...) {
71456       {
71457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71458       };
71459     }
71460   }
71461
71462   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
71463   return jresult;
71464 }
71465
71466
71467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
71468   int jresult ;
71469   int result;
71470
71471   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
71472   jresult = (int)result;
71473   return jresult;
71474 }
71475
71476
71477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
71478   int jresult ;
71479   int result;
71480
71481   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
71482   jresult = (int)result;
71483   return jresult;
71484 }
71485
71486
71487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
71488   int jresult ;
71489   int result;
71490
71491   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
71492   jresult = (int)result;
71493   return jresult;
71494 }
71495
71496
71497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
71498   int jresult ;
71499   int result;
71500
71501   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
71502   jresult = (int)result;
71503   return jresult;
71504 }
71505
71506
71507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
71508   int jresult ;
71509   int result;
71510
71511   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
71512   jresult = (int)result;
71513   return jresult;
71514 }
71515
71516
71517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
71518   int jresult ;
71519   int result;
71520
71521   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
71522   jresult = (int)result;
71523   return jresult;
71524 }
71525
71526
71527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
71528   int jresult ;
71529   int result;
71530
71531   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
71532   jresult = (int)result;
71533   return jresult;
71534 }
71535
71536
71537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
71538   int jresult ;
71539   int result;
71540
71541   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
71542   jresult = (int)result;
71543   return jresult;
71544 }
71545
71546
71547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
71548   int jresult ;
71549   int result;
71550
71551   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
71552   jresult = (int)result;
71553   return jresult;
71554 }
71555
71556
71557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
71558   void * jresult ;
71559   Dali::Toolkit::ScrollBar::Property *result = 0 ;
71560
71561   {
71562     try {
71563       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
71564     } catch (std::out_of_range& e) {
71565       {
71566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71567       };
71568     } catch (std::exception& e) {
71569       {
71570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71571       };
71572     } catch (Dali::DaliException e) {
71573       {
71574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71575       };
71576     } catch (...) {
71577       {
71578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71579       };
71580     }
71581   }
71582
71583   jresult = (void *)result;
71584   return jresult;
71585 }
71586
71587
71588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
71589   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
71590
71591   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
71592   {
71593     try {
71594       delete arg1;
71595     } catch (std::out_of_range& e) {
71596       {
71597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71598       };
71599     } catch (std::exception& e) {
71600       {
71601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71602       };
71603     } catch (Dali::DaliException e) {
71604       {
71605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71606       };
71607     } catch (...) {
71608       {
71609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71610       };
71611     }
71612   }
71613
71614 }
71615
71616
71617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
71618   void * jresult ;
71619   Dali::Toolkit::ScrollBar *result = 0 ;
71620
71621   {
71622     try {
71623       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
71624     } catch (std::out_of_range& e) {
71625       {
71626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71627       };
71628     } catch (std::exception& e) {
71629       {
71630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71631       };
71632     } catch (Dali::DaliException e) {
71633       {
71634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71635       };
71636     } catch (...) {
71637       {
71638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71639       };
71640     }
71641   }
71642
71643   jresult = (void *)result;
71644   return jresult;
71645 }
71646
71647
71648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
71649   void * jresult ;
71650   Dali::Toolkit::ScrollBar *arg1 = 0 ;
71651   Dali::Toolkit::ScrollBar *result = 0 ;
71652
71653   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71654   if (!arg1) {
71655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71656     return 0;
71657   }
71658   {
71659     try {
71660       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
71661     } catch (std::out_of_range& e) {
71662       {
71663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71664       };
71665     } catch (std::exception& e) {
71666       {
71667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71668       };
71669     } catch (Dali::DaliException e) {
71670       {
71671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71672       };
71673     } catch (...) {
71674       {
71675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71676       };
71677     }
71678   }
71679
71680   jresult = (void *)result;
71681   return jresult;
71682 }
71683
71684
71685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
71686   void * jresult ;
71687   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71688   Dali::Toolkit::ScrollBar *arg2 = 0 ;
71689   Dali::Toolkit::ScrollBar *result = 0 ;
71690
71691   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71692   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
71693   if (!arg2) {
71694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
71695     return 0;
71696   }
71697   {
71698     try {
71699       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
71700     } catch (std::out_of_range& e) {
71701       {
71702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71703       };
71704     } catch (std::exception& e) {
71705       {
71706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71707       };
71708     } catch (Dali::DaliException e) {
71709       {
71710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71711       };
71712     } catch (...) {
71713       {
71714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71715       };
71716     }
71717   }
71718
71719   jresult = (void *)result;
71720   return jresult;
71721 }
71722
71723
71724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
71725   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71726
71727   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71728   {
71729     try {
71730       delete arg1;
71731     } catch (std::out_of_range& e) {
71732       {
71733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71734       };
71735     } catch (std::exception& e) {
71736       {
71737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71738       };
71739     } catch (Dali::DaliException e) {
71740       {
71741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71742       };
71743     } catch (...) {
71744       {
71745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71746       };
71747     }
71748   }
71749
71750 }
71751
71752
71753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
71754   void * jresult ;
71755   Dali::Toolkit::ScrollBar::Direction arg1 ;
71756   Dali::Toolkit::ScrollBar result;
71757
71758   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
71759   {
71760     try {
71761       result = Dali::Toolkit::ScrollBar::New(arg1);
71762     } catch (std::out_of_range& e) {
71763       {
71764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71765       };
71766     } catch (std::exception& e) {
71767       {
71768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71769       };
71770     } catch (Dali::DaliException e) {
71771       {
71772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71773       };
71774     } catch (...) {
71775       {
71776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71777       };
71778     }
71779   }
71780
71781   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71782   return jresult;
71783 }
71784
71785
71786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
71787   void * jresult ;
71788   Dali::Toolkit::ScrollBar result;
71789
71790   {
71791     try {
71792       result = Dali::Toolkit::ScrollBar::New();
71793     } catch (std::out_of_range& e) {
71794       {
71795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71796       };
71797     } catch (std::exception& e) {
71798       {
71799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71800       };
71801     } catch (Dali::DaliException e) {
71802       {
71803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71804       };
71805     } catch (...) {
71806       {
71807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71808       };
71809     }
71810   }
71811
71812   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71813   return jresult;
71814 }
71815
71816
71817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
71818   void * jresult ;
71819   Dali::BaseHandle arg1 ;
71820   Dali::BaseHandle *argp1 ;
71821   Dali::Toolkit::ScrollBar result;
71822
71823   argp1 = (Dali::BaseHandle *)jarg1;
71824   if (!argp1) {
71825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71826     return 0;
71827   }
71828   arg1 = *argp1;
71829   {
71830     try {
71831       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
71832     } catch (std::out_of_range& e) {
71833       {
71834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71835       };
71836     } catch (std::exception& e) {
71837       {
71838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71839       };
71840     } catch (Dali::DaliException e) {
71841       {
71842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71843       };
71844     } catch (...) {
71845       {
71846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71847       };
71848     }
71849   }
71850
71851   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
71852   return jresult;
71853 }
71854
71855
71856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
71857   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71858   Dali::Handle arg2 ;
71859   Dali::Property::Index arg3 ;
71860   Dali::Property::Index arg4 ;
71861   Dali::Property::Index arg5 ;
71862   Dali::Property::Index arg6 ;
71863   Dali::Handle *argp2 ;
71864
71865   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71866   argp2 = (Dali::Handle *)jarg2;
71867   if (!argp2) {
71868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
71869     return ;
71870   }
71871   arg2 = *argp2;
71872   arg3 = (Dali::Property::Index)jarg3;
71873   arg4 = (Dali::Property::Index)jarg4;
71874   arg5 = (Dali::Property::Index)jarg5;
71875   arg6 = (Dali::Property::Index)jarg6;
71876   {
71877     try {
71878       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
71879     } catch (std::out_of_range& e) {
71880       {
71881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71882       };
71883     } catch (std::exception& e) {
71884       {
71885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71886       };
71887     } catch (Dali::DaliException e) {
71888       {
71889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71890       };
71891     } catch (...) {
71892       {
71893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71894       };
71895     }
71896   }
71897
71898 }
71899
71900
71901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
71902   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71903   Dali::Actor arg2 ;
71904   Dali::Actor *argp2 ;
71905
71906   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71907   argp2 = (Dali::Actor *)jarg2;
71908   if (!argp2) {
71909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71910     return ;
71911   }
71912   arg2 = *argp2;
71913   {
71914     try {
71915       (arg1)->SetScrollIndicator(arg2);
71916     } catch (std::out_of_range& e) {
71917       {
71918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71919       };
71920     } catch (std::exception& e) {
71921       {
71922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71923       };
71924     } catch (Dali::DaliException e) {
71925       {
71926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71927       };
71928     } catch (...) {
71929       {
71930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71931       };
71932     }
71933   }
71934
71935 }
71936
71937
71938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
71939   void * jresult ;
71940   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71941   Dali::Actor result;
71942
71943   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71944   {
71945     try {
71946       result = (arg1)->GetScrollIndicator();
71947     } catch (std::out_of_range& e) {
71948       {
71949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71950       };
71951     } catch (std::exception& e) {
71952       {
71953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71954       };
71955     } catch (Dali::DaliException e) {
71956       {
71957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71958       };
71959     } catch (...) {
71960       {
71961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71962       };
71963     }
71964   }
71965
71966   jresult = new Dali::Actor((const Dali::Actor &)result);
71967   return jresult;
71968 }
71969
71970
71971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
71972   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71973   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
71974
71975   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71976   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
71977   if (!arg2) {
71978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
71979     return ;
71980   }
71981   {
71982     try {
71983       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
71984     } catch (std::out_of_range& e) {
71985       {
71986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71987       };
71988     } catch (std::exception& e) {
71989       {
71990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71991       };
71992     } catch (Dali::DaliException e) {
71993       {
71994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71995       };
71996     } catch (...) {
71997       {
71998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71999       };
72000     }
72001   }
72002
72003 }
72004
72005
72006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72007   void * jresult ;
72008   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72009
72010   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72011   {
72012     try {
72013       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()));
72014     } catch (std::out_of_range& e) {
72015       {
72016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72017       };
72018     } catch (std::exception& e) {
72019       {
72020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72021       };
72022     } catch (...) {
72023       {
72024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72025       };
72026     }
72027   }
72028   return jresult;
72029 }
72030
72031
72032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72033   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72034   Dali::Toolkit::ScrollBar::Direction arg2 ;
72035
72036   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72037   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72038   {
72039     try {
72040       (arg1)->SetScrollDirection(arg2);
72041     } catch (std::out_of_range& e) {
72042       {
72043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72044       };
72045     } catch (std::exception& e) {
72046       {
72047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72048       };
72049     } catch (Dali::DaliException e) {
72050       {
72051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72052       };
72053     } catch (...) {
72054       {
72055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72056       };
72057     }
72058   }
72059
72060 }
72061
72062
72063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72064   int jresult ;
72065   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72066   Dali::Toolkit::ScrollBar::Direction result;
72067
72068   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72069   {
72070     try {
72071       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
72072     } catch (std::out_of_range& e) {
72073       {
72074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72075       };
72076     } catch (std::exception& e) {
72077       {
72078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72079       };
72080     } catch (Dali::DaliException e) {
72081       {
72082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72083       };
72084     } catch (...) {
72085       {
72086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72087       };
72088     }
72089   }
72090
72091   jresult = (int)result;
72092   return jresult;
72093 }
72094
72095
72096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
72097   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72098   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
72099
72100   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72101   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
72102   {
72103     try {
72104       (arg1)->SetIndicatorHeightPolicy(arg2);
72105     } catch (std::out_of_range& e) {
72106       {
72107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72108       };
72109     } catch (std::exception& e) {
72110       {
72111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72112       };
72113     } catch (Dali::DaliException e) {
72114       {
72115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72116       };
72117     } catch (...) {
72118       {
72119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72120       };
72121     }
72122   }
72123
72124 }
72125
72126
72127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
72128   int jresult ;
72129   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72130   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
72131
72132   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72133   {
72134     try {
72135       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
72136     } catch (std::out_of_range& e) {
72137       {
72138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72139       };
72140     } catch (std::exception& e) {
72141       {
72142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72143       };
72144     } catch (Dali::DaliException e) {
72145       {
72146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72147       };
72148     } catch (...) {
72149       {
72150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72151       };
72152     }
72153   }
72154
72155   jresult = (int)result;
72156   return jresult;
72157 }
72158
72159
72160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
72161   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72162   float arg2 ;
72163
72164   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72165   arg2 = (float)jarg2;
72166   {
72167     try {
72168       (arg1)->SetIndicatorFixedHeight(arg2);
72169     } catch (std::out_of_range& e) {
72170       {
72171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72172       };
72173     } catch (std::exception& e) {
72174       {
72175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72176       };
72177     } catch (Dali::DaliException e) {
72178       {
72179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72180       };
72181     } catch (...) {
72182       {
72183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72184       };
72185     }
72186   }
72187
72188 }
72189
72190
72191 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
72192   float jresult ;
72193   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72194   float result;
72195
72196   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72197   {
72198     try {
72199       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
72200     } catch (std::out_of_range& e) {
72201       {
72202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72203       };
72204     } catch (std::exception& e) {
72205       {
72206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72207       };
72208     } catch (Dali::DaliException e) {
72209       {
72210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72211       };
72212     } catch (...) {
72213       {
72214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72215       };
72216     }
72217   }
72218
72219   jresult = result;
72220   return jresult;
72221 }
72222
72223
72224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
72225   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72226   float arg2 ;
72227
72228   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72229   arg2 = (float)jarg2;
72230   {
72231     try {
72232       (arg1)->SetIndicatorShowDuration(arg2);
72233     } catch (std::out_of_range& e) {
72234       {
72235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72236       };
72237     } catch (std::exception& e) {
72238       {
72239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72240       };
72241     } catch (Dali::DaliException e) {
72242       {
72243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72244       };
72245     } catch (...) {
72246       {
72247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72248       };
72249     }
72250   }
72251
72252 }
72253
72254
72255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
72256   float jresult ;
72257   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72258   float result;
72259
72260   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72261   {
72262     try {
72263       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
72264     } catch (std::out_of_range& e) {
72265       {
72266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72267       };
72268     } catch (std::exception& e) {
72269       {
72270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72271       };
72272     } catch (Dali::DaliException e) {
72273       {
72274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72275       };
72276     } catch (...) {
72277       {
72278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72279       };
72280     }
72281   }
72282
72283   jresult = result;
72284   return jresult;
72285 }
72286
72287
72288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
72289   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72290   float arg2 ;
72291
72292   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72293   arg2 = (float)jarg2;
72294   {
72295     try {
72296       (arg1)->SetIndicatorHideDuration(arg2);
72297     } catch (std::out_of_range& e) {
72298       {
72299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72300       };
72301     } catch (std::exception& e) {
72302       {
72303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72304       };
72305     } catch (Dali::DaliException e) {
72306       {
72307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72308       };
72309     } catch (...) {
72310       {
72311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72312       };
72313     }
72314   }
72315
72316 }
72317
72318
72319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
72320   float jresult ;
72321   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72322   float result;
72323
72324   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72325   {
72326     try {
72327       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
72328     } catch (std::out_of_range& e) {
72329       {
72330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72331       };
72332     } catch (std::exception& e) {
72333       {
72334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72335       };
72336     } catch (Dali::DaliException e) {
72337       {
72338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72339       };
72340     } catch (...) {
72341       {
72342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72343       };
72344     }
72345   }
72346
72347   jresult = result;
72348   return jresult;
72349 }
72350
72351
72352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
72353   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72354
72355   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72356   {
72357     try {
72358       (arg1)->ShowIndicator();
72359     } catch (std::out_of_range& e) {
72360       {
72361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72362       };
72363     } catch (std::exception& e) {
72364       {
72365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72366       };
72367     } catch (Dali::DaliException e) {
72368       {
72369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72370       };
72371     } catch (...) {
72372       {
72373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72374       };
72375     }
72376   }
72377
72378 }
72379
72380
72381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
72382   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72383
72384   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72385   {
72386     try {
72387       (arg1)->HideIndicator();
72388     } catch (std::out_of_range& e) {
72389       {
72390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72391       };
72392     } catch (std::exception& e) {
72393       {
72394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72395       };
72396     } catch (Dali::DaliException e) {
72397       {
72398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72399       };
72400     } catch (...) {
72401       {
72402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72403       };
72404     }
72405   }
72406
72407 }
72408
72409
72410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
72411   void * jresult ;
72412   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72413   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
72414
72415   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72416   {
72417     try {
72418       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
72419     } catch (std::out_of_range& e) {
72420       {
72421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72422       };
72423     } catch (std::exception& e) {
72424       {
72425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72426       };
72427     } catch (Dali::DaliException e) {
72428       {
72429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72430       };
72431     } catch (...) {
72432       {
72433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72434       };
72435     }
72436   }
72437
72438   jresult = (void *)result;
72439   return jresult;
72440 }
72441
72442
72443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
72444   void * jresult ;
72445   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72446   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
72447
72448   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72449   {
72450     try {
72451       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
72452     } catch (std::out_of_range& e) {
72453       {
72454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72455       };
72456     } catch (std::exception& e) {
72457       {
72458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72459       };
72460     } catch (Dali::DaliException e) {
72461       {
72462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72463       };
72464     } catch (...) {
72465       {
72466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72467       };
72468     }
72469   }
72470
72471   jresult = (void *)result;
72472   return jresult;
72473 }
72474
72475
72476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
72477   int jresult ;
72478   int result;
72479
72480   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
72481   jresult = (int)result;
72482   return jresult;
72483 }
72484
72485
72486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
72487   int jresult ;
72488   int result;
72489
72490   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
72491   jresult = (int)result;
72492   return jresult;
72493 }
72494
72495
72496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
72497   int jresult ;
72498   int result;
72499
72500   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
72501   jresult = (int)result;
72502   return jresult;
72503 }
72504
72505
72506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
72507   int jresult ;
72508   int result;
72509
72510   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
72511   jresult = (int)result;
72512   return jresult;
72513 }
72514
72515
72516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
72517   int jresult ;
72518   int result;
72519
72520   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
72521   jresult = (int)result;
72522   return jresult;
72523 }
72524
72525
72526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
72527   int jresult ;
72528   int result;
72529
72530   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
72531   jresult = (int)result;
72532   return jresult;
72533 }
72534
72535
72536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
72537   int jresult ;
72538   int result;
72539
72540   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
72541   jresult = (int)result;
72542   return jresult;
72543 }
72544
72545
72546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
72547   int jresult ;
72548   int result;
72549
72550   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
72551   jresult = (int)result;
72552   return jresult;
72553 }
72554
72555
72556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
72557   int jresult ;
72558   int result;
72559
72560   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
72561   jresult = (int)result;
72562   return jresult;
72563 }
72564
72565
72566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
72567   int jresult ;
72568   int result;
72569
72570   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
72571   jresult = (int)result;
72572   return jresult;
72573 }
72574
72575
72576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
72577   int jresult ;
72578   int result;
72579
72580   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
72581   jresult = (int)result;
72582   return jresult;
72583 }
72584
72585
72586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
72587   int jresult ;
72588   int result;
72589
72590   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
72591   jresult = (int)result;
72592   return jresult;
72593 }
72594
72595
72596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
72597   int jresult ;
72598   int result;
72599
72600   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
72601   jresult = (int)result;
72602   return jresult;
72603 }
72604
72605
72606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
72607   int jresult ;
72608   int result;
72609
72610   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
72611   jresult = (int)result;
72612   return jresult;
72613 }
72614
72615
72616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
72617   void * jresult ;
72618   Dali::Toolkit::Scrollable::Property *result = 0 ;
72619
72620   {
72621     try {
72622       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
72623     } catch (std::out_of_range& e) {
72624       {
72625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72626       };
72627     } catch (std::exception& e) {
72628       {
72629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72630       };
72631     } catch (Dali::DaliException e) {
72632       {
72633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72634       };
72635     } catch (...) {
72636       {
72637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72638       };
72639     }
72640   }
72641
72642   jresult = (void *)result;
72643   return jresult;
72644 }
72645
72646
72647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
72648   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
72649
72650   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
72651   {
72652     try {
72653       delete arg1;
72654     } catch (std::out_of_range& e) {
72655       {
72656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72657       };
72658     } catch (std::exception& e) {
72659       {
72660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72661       };
72662     } catch (Dali::DaliException e) {
72663       {
72664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72665       };
72666     } catch (...) {
72667       {
72668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72669       };
72670     }
72671   }
72672
72673 }
72674
72675
72676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
72677   void * jresult ;
72678   Dali::Toolkit::Scrollable *result = 0 ;
72679
72680   {
72681     try {
72682       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
72683     } catch (std::out_of_range& e) {
72684       {
72685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72686       };
72687     } catch (std::exception& e) {
72688       {
72689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72690       };
72691     } catch (Dali::DaliException e) {
72692       {
72693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72694       };
72695     } catch (...) {
72696       {
72697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72698       };
72699     }
72700   }
72701
72702   jresult = (void *)result;
72703   return jresult;
72704 }
72705
72706
72707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
72708   void * jresult ;
72709   Dali::Toolkit::Scrollable *arg1 = 0 ;
72710   Dali::Toolkit::Scrollable *result = 0 ;
72711
72712   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72713   if (!arg1) {
72714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72715     return 0;
72716   }
72717   {
72718     try {
72719       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
72720     } catch (std::out_of_range& e) {
72721       {
72722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72723       };
72724     } catch (std::exception& e) {
72725       {
72726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72727       };
72728     } catch (Dali::DaliException e) {
72729       {
72730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72731       };
72732     } catch (...) {
72733       {
72734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72735       };
72736     }
72737   }
72738
72739   jresult = (void *)result;
72740   return jresult;
72741 }
72742
72743
72744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
72745   void * jresult ;
72746   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72747   Dali::Toolkit::Scrollable *arg2 = 0 ;
72748   Dali::Toolkit::Scrollable *result = 0 ;
72749
72750   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72751   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
72752   if (!arg2) {
72753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
72754     return 0;
72755   }
72756   {
72757     try {
72758       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
72759     } catch (std::out_of_range& e) {
72760       {
72761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72762       };
72763     } catch (std::exception& e) {
72764       {
72765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72766       };
72767     } catch (Dali::DaliException e) {
72768       {
72769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72770       };
72771     } catch (...) {
72772       {
72773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72774       };
72775     }
72776   }
72777
72778   jresult = (void *)result;
72779   return jresult;
72780 }
72781
72782
72783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
72784   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72785
72786   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72787   {
72788     try {
72789       delete arg1;
72790     } catch (std::out_of_range& e) {
72791       {
72792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72793       };
72794     } catch (std::exception& e) {
72795       {
72796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72797       };
72798     } catch (Dali::DaliException e) {
72799       {
72800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72801       };
72802     } catch (...) {
72803       {
72804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72805       };
72806     }
72807   }
72808
72809 }
72810
72811
72812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
72813   void * jresult ;
72814   Dali::BaseHandle arg1 ;
72815   Dali::BaseHandle *argp1 ;
72816   Dali::Toolkit::Scrollable result;
72817
72818   argp1 = (Dali::BaseHandle *)jarg1;
72819   if (!argp1) {
72820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72821     return 0;
72822   }
72823   arg1 = *argp1;
72824   {
72825     try {
72826       result = Dali::Toolkit::Scrollable::DownCast(arg1);
72827     } catch (std::out_of_range& e) {
72828       {
72829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72830       };
72831     } catch (std::exception& e) {
72832       {
72833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72834       };
72835     } catch (Dali::DaliException e) {
72836       {
72837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72838       };
72839     } catch (...) {
72840       {
72841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72842       };
72843     }
72844   }
72845
72846   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
72847   return jresult;
72848 }
72849
72850
72851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
72852   unsigned int jresult ;
72853   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72854   bool result;
72855
72856   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72857   {
72858     try {
72859       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
72860     } catch (std::out_of_range& e) {
72861       {
72862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72863       };
72864     } catch (std::exception& e) {
72865       {
72866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72867       };
72868     } catch (Dali::DaliException e) {
72869       {
72870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72871       };
72872     } catch (...) {
72873       {
72874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72875       };
72876     }
72877   }
72878
72879   jresult = result;
72880   return jresult;
72881 }
72882
72883
72884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
72885   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72886   bool arg2 ;
72887
72888   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72889   arg2 = jarg2 ? true : false;
72890   {
72891     try {
72892       (arg1)->SetOvershootEnabled(arg2);
72893     } catch (std::out_of_range& e) {
72894       {
72895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72896       };
72897     } catch (std::exception& e) {
72898       {
72899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72900       };
72901     } catch (Dali::DaliException e) {
72902       {
72903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72904       };
72905     } catch (...) {
72906       {
72907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72908       };
72909     }
72910   }
72911
72912 }
72913
72914
72915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
72916   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72917   Dali::Vector4 *arg2 = 0 ;
72918
72919   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72920   arg2 = (Dali::Vector4 *)jarg2;
72921   if (!arg2) {
72922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
72923     return ;
72924   }
72925   {
72926     try {
72927       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
72928     } catch (std::out_of_range& e) {
72929       {
72930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72931       };
72932     } catch (std::exception& e) {
72933       {
72934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72935       };
72936     } catch (Dali::DaliException e) {
72937       {
72938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72939       };
72940     } catch (...) {
72941       {
72942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72943       };
72944     }
72945   }
72946
72947 }
72948
72949
72950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
72951   void * jresult ;
72952   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72953   Dali::Vector4 result;
72954
72955   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72956   {
72957     try {
72958       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
72959     } catch (std::out_of_range& e) {
72960       {
72961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72962       };
72963     } catch (std::exception& e) {
72964       {
72965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72966       };
72967     } catch (Dali::DaliException e) {
72968       {
72969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72970       };
72971     } catch (...) {
72972       {
72973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72974       };
72975     }
72976   }
72977
72978   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
72979   return jresult;
72980 }
72981
72982
72983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
72984   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
72985   float arg2 ;
72986
72987   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
72988   arg2 = (float)jarg2;
72989   {
72990     try {
72991       (arg1)->SetOvershootAnimationSpeed(arg2);
72992     } catch (std::out_of_range& e) {
72993       {
72994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72995       };
72996     } catch (std::exception& e) {
72997       {
72998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72999       };
73000     } catch (Dali::DaliException e) {
73001       {
73002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73003       };
73004     } catch (...) {
73005       {
73006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73007       };
73008     }
73009   }
73010
73011 }
73012
73013
73014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73015   float jresult ;
73016   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73017   float result;
73018
73019   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73020   {
73021     try {
73022       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73023     } catch (std::out_of_range& e) {
73024       {
73025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73026       };
73027     } catch (std::exception& e) {
73028       {
73029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73030       };
73031     } catch (Dali::DaliException e) {
73032       {
73033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73034       };
73035     } catch (...) {
73036       {
73037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73038       };
73039     }
73040   }
73041
73042   jresult = result;
73043   return jresult;
73044 }
73045
73046
73047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73048   void * jresult ;
73049   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73050   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73051
73052   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73053   {
73054     try {
73055       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73056     } catch (std::out_of_range& e) {
73057       {
73058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73059       };
73060     } catch (std::exception& e) {
73061       {
73062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73063       };
73064     } catch (Dali::DaliException e) {
73065       {
73066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73067       };
73068     } catch (...) {
73069       {
73070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73071       };
73072     }
73073   }
73074
73075   jresult = (void *)result;
73076   return jresult;
73077 }
73078
73079
73080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
73081   void * jresult ;
73082   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73083   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
73084
73085   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73086   {
73087     try {
73088       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
73089     } catch (std::out_of_range& e) {
73090       {
73091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73092       };
73093     } catch (std::exception& e) {
73094       {
73095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73096       };
73097     } catch (Dali::DaliException e) {
73098       {
73099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73100       };
73101     } catch (...) {
73102       {
73103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73104       };
73105     }
73106   }
73107
73108   jresult = (void *)result;
73109   return jresult;
73110 }
73111
73112
73113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
73114   void * jresult ;
73115   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73116   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
73117
73118   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73119   {
73120     try {
73121       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
73122     } catch (std::out_of_range& e) {
73123       {
73124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73125       };
73126     } catch (std::exception& e) {
73127       {
73128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73129       };
73130     } catch (Dali::DaliException e) {
73131       {
73132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73133       };
73134     } catch (...) {
73135       {
73136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73137       };
73138     }
73139   }
73140
73141   jresult = (void *)result;
73142   return jresult;
73143 }
73144
73145
73146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
73147   unsigned int jresult ;
73148   Dali::Toolkit::ControlOrientation::Type arg1 ;
73149   bool result;
73150
73151   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73152   {
73153     try {
73154       result = (bool)Dali::Toolkit::IsVertical(arg1);
73155     } catch (std::out_of_range& e) {
73156       {
73157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73158       };
73159     } catch (std::exception& e) {
73160       {
73161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73162       };
73163     } catch (Dali::DaliException e) {
73164       {
73165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73166       };
73167     } catch (...) {
73168       {
73169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73170       };
73171     }
73172   }
73173
73174   jresult = result;
73175   return jresult;
73176 }
73177
73178
73179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
73180   unsigned int jresult ;
73181   Dali::Toolkit::ControlOrientation::Type arg1 ;
73182   bool result;
73183
73184   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
73185   {
73186     try {
73187       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
73188     } catch (std::out_of_range& e) {
73189       {
73190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73191       };
73192     } catch (std::exception& e) {
73193       {
73194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73195       };
73196     } catch (Dali::DaliException e) {
73197       {
73198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73199       };
73200     } catch (...) {
73201       {
73202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73203       };
73204     }
73205   }
73206
73207   jresult = result;
73208   return jresult;
73209 }
73210
73211
73212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
73213   void * jresult ;
73214   unsigned int arg1 ;
73215   unsigned int arg2 ;
73216   Dali::Toolkit::ItemRange *result = 0 ;
73217
73218   arg1 = (unsigned int)jarg1;
73219   arg2 = (unsigned int)jarg2;
73220   {
73221     try {
73222       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
73223     } catch (std::out_of_range& e) {
73224       {
73225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73226       };
73227     } catch (std::exception& e) {
73228       {
73229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73230       };
73231     } catch (Dali::DaliException e) {
73232       {
73233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73234       };
73235     } catch (...) {
73236       {
73237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73238       };
73239     }
73240   }
73241
73242   jresult = (void *)result;
73243   return jresult;
73244 }
73245
73246
73247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
73248   void * jresult ;
73249   Dali::Toolkit::ItemRange *arg1 = 0 ;
73250   Dali::Toolkit::ItemRange *result = 0 ;
73251
73252   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73253   if (!arg1) {
73254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73255     return 0;
73256   }
73257   {
73258     try {
73259       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
73260     } catch (std::out_of_range& e) {
73261       {
73262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73263       };
73264     } catch (std::exception& e) {
73265       {
73266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73267       };
73268     } catch (Dali::DaliException e) {
73269       {
73270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73271       };
73272     } catch (...) {
73273       {
73274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73275       };
73276     }
73277   }
73278
73279   jresult = (void *)result;
73280   return jresult;
73281 }
73282
73283
73284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
73285   void * jresult ;
73286   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73287   Dali::Toolkit::ItemRange *arg2 = 0 ;
73288   Dali::Toolkit::ItemRange *result = 0 ;
73289
73290   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73291   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73292   if (!arg2) {
73293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73294     return 0;
73295   }
73296   {
73297     try {
73298       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
73299     } catch (std::out_of_range& e) {
73300       {
73301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73302       };
73303     } catch (std::exception& e) {
73304       {
73305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73306       };
73307     } catch (Dali::DaliException e) {
73308       {
73309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73310       };
73311     } catch (...) {
73312       {
73313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73314       };
73315     }
73316   }
73317
73318   jresult = (void *)result;
73319   return jresult;
73320 }
73321
73322
73323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
73324   unsigned int jresult ;
73325   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73326   unsigned int arg2 ;
73327   bool result;
73328
73329   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73330   arg2 = (unsigned int)jarg2;
73331   {
73332     try {
73333       result = (bool)(arg1)->Within(arg2);
73334     } catch (std::out_of_range& e) {
73335       {
73336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73337       };
73338     } catch (std::exception& e) {
73339       {
73340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73341       };
73342     } catch (Dali::DaliException e) {
73343       {
73344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73345       };
73346     } catch (...) {
73347       {
73348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73349       };
73350     }
73351   }
73352
73353   jresult = result;
73354   return jresult;
73355 }
73356
73357
73358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
73359   void * jresult ;
73360   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73361   Dali::Toolkit::ItemRange *arg2 = 0 ;
73362   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73363
73364   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73365   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
73366   if (!arg2) {
73367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
73368     return 0;
73369   }
73370   {
73371     try {
73372       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
73373     } catch (std::out_of_range& e) {
73374       {
73375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73376       };
73377     } catch (std::exception& e) {
73378       {
73379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73380       };
73381     } catch (Dali::DaliException e) {
73382       {
73383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73384       };
73385     } catch (...) {
73386       {
73387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73388       };
73389     }
73390   }
73391
73392   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73393   return jresult;
73394 }
73395
73396
73397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
73398   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73399   unsigned int arg2 ;
73400
73401   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73402   arg2 = (unsigned int)jarg2;
73403   if (arg1) (arg1)->begin = arg2;
73404 }
73405
73406
73407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
73408   unsigned int jresult ;
73409   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73410   unsigned int result;
73411
73412   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73413   result = (unsigned int) ((arg1)->begin);
73414   jresult = result;
73415   return jresult;
73416 }
73417
73418
73419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
73420   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73421   unsigned int arg2 ;
73422
73423   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73424   arg2 = (unsigned int)jarg2;
73425   if (arg1) (arg1)->end = arg2;
73426 }
73427
73428
73429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
73430   unsigned int jresult ;
73431   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73432   unsigned int result;
73433
73434   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73435   result = (unsigned int) ((arg1)->end);
73436   jresult = result;
73437   return jresult;
73438 }
73439
73440
73441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
73442   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
73443
73444   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
73445   {
73446     try {
73447       delete arg1;
73448     } catch (std::out_of_range& e) {
73449       {
73450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73451       };
73452     } catch (std::exception& e) {
73453       {
73454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73455       };
73456     } catch (Dali::DaliException e) {
73457       {
73458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73459       };
73460     } catch (...) {
73461       {
73462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73463       };
73464     }
73465   }
73466
73467 }
73468
73469
73470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
73471   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73472
73473   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73474   {
73475     try {
73476       delete arg1;
73477     } catch (std::out_of_range& e) {
73478       {
73479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73480       };
73481     } catch (std::exception& e) {
73482       {
73483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73484       };
73485     } catch (Dali::DaliException e) {
73486       {
73487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73488       };
73489     } catch (...) {
73490       {
73491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73492       };
73493     }
73494   }
73495
73496 }
73497
73498
73499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
73500   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73501   Dali::Toolkit::ControlOrientation::Type arg2 ;
73502
73503   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73504   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
73505   {
73506     try {
73507       (arg1)->SetOrientation(arg2);
73508     } catch (std::out_of_range& e) {
73509       {
73510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73511       };
73512     } catch (std::exception& e) {
73513       {
73514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73515       };
73516     } catch (Dali::DaliException e) {
73517       {
73518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73519       };
73520     } catch (...) {
73521       {
73522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73523       };
73524     }
73525   }
73526
73527 }
73528
73529
73530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
73531   int jresult ;
73532   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73533   Dali::Toolkit::ControlOrientation::Type result;
73534
73535   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73536   {
73537     try {
73538       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
73539     } catch (std::out_of_range& e) {
73540       {
73541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73542       };
73543     } catch (std::exception& e) {
73544       {
73545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73546       };
73547     } catch (Dali::DaliException e) {
73548       {
73549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73550       };
73551     } catch (...) {
73552       {
73553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73554       };
73555     }
73556   }
73557
73558   jresult = (int)result;
73559   return jresult;
73560 }
73561
73562
73563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
73564   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73565   Dali::Property::Map *arg2 = 0 ;
73566
73567   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73568   arg2 = (Dali::Property::Map *)jarg2;
73569   if (!arg2) {
73570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
73571     return ;
73572   }
73573   {
73574     try {
73575       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
73576     } catch (std::out_of_range& e) {
73577       {
73578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73579       };
73580     } catch (std::exception& e) {
73581       {
73582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73583       };
73584     } catch (Dali::DaliException e) {
73585       {
73586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73587       };
73588     } catch (...) {
73589       {
73590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73591       };
73592     }
73593   }
73594
73595 }
73596
73597
73598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
73599   void * jresult ;
73600   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73601   Dali::Property::Map result;
73602
73603   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73604   {
73605     try {
73606       result = (arg1)->GetLayoutProperties();
73607     } catch (std::out_of_range& e) {
73608       {
73609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73610       };
73611     } catch (std::exception& e) {
73612       {
73613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73614       };
73615     } catch (Dali::DaliException e) {
73616       {
73617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73618       };
73619     } catch (...) {
73620       {
73621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73622       };
73623     }
73624   }
73625
73626   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
73627   return jresult;
73628 }
73629
73630
73631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73632   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73633   unsigned int arg2 ;
73634   Dali::Vector3 *arg3 = 0 ;
73635   Dali::Vector3 *arg4 = 0 ;
73636
73637   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73638   arg2 = (unsigned int)jarg2;
73639   arg3 = (Dali::Vector3 *)jarg3;
73640   if (!arg3) {
73641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73642     return ;
73643   }
73644   arg4 = (Dali::Vector3 *)jarg4;
73645   if (!arg4) {
73646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73647     return ;
73648   }
73649   {
73650     try {
73651       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73652     } catch (std::out_of_range& e) {
73653       {
73654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73655       };
73656     } catch (std::exception& e) {
73657       {
73658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73659       };
73660     } catch (Dali::DaliException e) {
73661       {
73662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73663       };
73664     } catch (...) {
73665       {
73666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73667       };
73668     }
73669   }
73670
73671 }
73672
73673
73674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
73675   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73676   Dali::Vector3 *arg2 = 0 ;
73677
73678   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73679   arg2 = (Dali::Vector3 *)jarg2;
73680   if (!arg2) {
73681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73682     return ;
73683   }
73684   {
73685     try {
73686       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
73687     } catch (std::out_of_range& e) {
73688       {
73689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73690       };
73691     } catch (std::exception& e) {
73692       {
73693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73694       };
73695     } catch (Dali::DaliException e) {
73696       {
73697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73698       };
73699     } catch (...) {
73700       {
73701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73702       };
73703     }
73704   }
73705
73706 }
73707
73708
73709 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
73710   float jresult ;
73711   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73712   unsigned int arg2 ;
73713   Dali::Vector3 arg3 ;
73714   Dali::Vector3 *argp3 ;
73715   float result;
73716
73717   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73718   arg2 = (unsigned int)jarg2;
73719   argp3 = (Dali::Vector3 *)jarg3;
73720   if (!argp3) {
73721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73722     return 0;
73723   }
73724   arg3 = *argp3;
73725   {
73726     try {
73727       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
73728     } catch (std::out_of_range& e) {
73729       {
73730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73731       };
73732     } catch (std::exception& e) {
73733       {
73734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73735       };
73736     } catch (Dali::DaliException e) {
73737       {
73738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73739       };
73740     } catch (...) {
73741       {
73742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73743       };
73744     }
73745   }
73746
73747   jresult = result;
73748   return jresult;
73749 }
73750
73751
73752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
73753   float jresult ;
73754   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73755   float arg2 ;
73756   float result;
73757
73758   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73759   arg2 = (float)jarg2;
73760   {
73761     try {
73762       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
73763     } catch (std::out_of_range& e) {
73764       {
73765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73766       };
73767     } catch (std::exception& e) {
73768       {
73769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73770       };
73771     } catch (Dali::DaliException e) {
73772       {
73773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73774       };
73775     } catch (...) {
73776       {
73777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73778       };
73779     }
73780   }
73781
73782   jresult = result;
73783   return jresult;
73784 }
73785
73786
73787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
73788   float jresult ;
73789   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73790   unsigned int arg2 ;
73791   float result;
73792
73793   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73794   arg2 = (unsigned int)jarg2;
73795   {
73796     try {
73797       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
73798     } catch (std::out_of_range& e) {
73799       {
73800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73801       };
73802     } catch (std::exception& e) {
73803       {
73804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73805       };
73806     } catch (Dali::DaliException e) {
73807       {
73808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73809       };
73810     } catch (...) {
73811       {
73812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73813       };
73814     }
73815   }
73816
73817   jresult = result;
73818   return jresult;
73819 }
73820
73821
73822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
73823   void * jresult ;
73824   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73825   float arg2 ;
73826   Dali::Vector3 arg3 ;
73827   Dali::Vector3 *argp3 ;
73828   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
73829
73830   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73831   arg2 = (float)jarg2;
73832   argp3 = (Dali::Vector3 *)jarg3;
73833   if (!argp3) {
73834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73835     return 0;
73836   }
73837   arg3 = *argp3;
73838   {
73839     try {
73840       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
73841     } catch (std::out_of_range& e) {
73842       {
73843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73844       };
73845     } catch (std::exception& e) {
73846       {
73847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73848       };
73849     } catch (Dali::DaliException e) {
73850       {
73851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73852       };
73853     } catch (...) {
73854       {
73855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73856       };
73857     }
73858   }
73859
73860   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
73861   return jresult;
73862 }
73863
73864
73865 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
73866   float jresult ;
73867   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73868   int arg2 ;
73869   float arg3 ;
73870   Dali::Vector3 *arg4 = 0 ;
73871   float result;
73872
73873   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73874   arg2 = (int)jarg2;
73875   arg3 = (float)jarg3;
73876   arg4 = (Dali::Vector3 *)jarg4;
73877   if (!arg4) {
73878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73879     return 0;
73880   }
73881   {
73882     try {
73883       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
73884     } catch (std::out_of_range& e) {
73885       {
73886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73887       };
73888     } catch (std::exception& e) {
73889       {
73890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73891       };
73892     } catch (Dali::DaliException e) {
73893       {
73894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73895       };
73896     } catch (...) {
73897       {
73898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73899       };
73900     }
73901   }
73902
73903   jresult = result;
73904   return jresult;
73905 }
73906
73907
73908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
73909   unsigned int jresult ;
73910   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73911   Dali::Vector3 arg2 ;
73912   Dali::Vector3 *argp2 ;
73913   unsigned int result;
73914
73915   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73916   argp2 = (Dali::Vector3 *)jarg2;
73917   if (!argp2) {
73918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73919     return 0;
73920   }
73921   arg2 = *argp2;
73922   {
73923     try {
73924       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
73925     } catch (std::out_of_range& e) {
73926       {
73927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73928       };
73929     } catch (std::exception& e) {
73930       {
73931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73932       };
73933     } catch (Dali::DaliException e) {
73934       {
73935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73936       };
73937     } catch (...) {
73938       {
73939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73940       };
73941     }
73942   }
73943
73944   jresult = result;
73945   return jresult;
73946 }
73947
73948
73949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
73950   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73951   unsigned int arg2 ;
73952   Dali::Vector3 *arg3 = 0 ;
73953   Dali::Vector3 *arg4 = 0 ;
73954
73955   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73956   arg2 = (unsigned int)jarg2;
73957   arg3 = (Dali::Vector3 *)jarg3;
73958   if (!arg3) {
73959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
73960     return ;
73961   }
73962   arg4 = (Dali::Vector3 *)jarg4;
73963   if (!arg4) {
73964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
73965     return ;
73966   }
73967   {
73968     try {
73969       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
73970     } catch (std::out_of_range& e) {
73971       {
73972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73973       };
73974     } catch (std::exception& e) {
73975       {
73976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73977       };
73978     } catch (Dali::DaliException e) {
73979       {
73980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73981       };
73982     } catch (...) {
73983       {
73984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73985       };
73986     }
73987   }
73988
73989 }
73990
73991
73992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
73993   void * jresult ;
73994   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
73995   Dali::Degree result;
73996
73997   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
73998   {
73999     try {
74000       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74001     } catch (std::out_of_range& e) {
74002       {
74003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74004       };
74005     } catch (std::exception& e) {
74006       {
74007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74008       };
74009     } catch (Dali::DaliException e) {
74010       {
74011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74012       };
74013     } catch (...) {
74014       {
74015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74016       };
74017     }
74018   }
74019
74020   jresult = new Dali::Degree((const Dali::Degree &)result);
74021   return jresult;
74022 }
74023
74024
74025 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74026   float jresult ;
74027   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74028   float result;
74029
74030   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74031   {
74032     try {
74033       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74034     } catch (std::out_of_range& e) {
74035       {
74036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74037       };
74038     } catch (std::exception& e) {
74039       {
74040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74041       };
74042     } catch (Dali::DaliException e) {
74043       {
74044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74045       };
74046     } catch (...) {
74047       {
74048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74049       };
74050     }
74051   }
74052
74053   jresult = result;
74054   return jresult;
74055 }
74056
74057
74058 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74059   float jresult ;
74060   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74061   float result;
74062
74063   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74064   {
74065     try {
74066       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
74067     } catch (std::out_of_range& e) {
74068       {
74069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74070       };
74071     } catch (std::exception& e) {
74072       {
74073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74074       };
74075     } catch (Dali::DaliException e) {
74076       {
74077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74078       };
74079     } catch (...) {
74080       {
74081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74082       };
74083     }
74084   }
74085
74086   jresult = result;
74087   return jresult;
74088 }
74089
74090
74091 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
74092   float jresult ;
74093   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74094   float result;
74095
74096   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74097   {
74098     try {
74099       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
74100     } catch (std::out_of_range& e) {
74101       {
74102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74103       };
74104     } catch (std::exception& e) {
74105       {
74106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74107       };
74108     } catch (Dali::DaliException e) {
74109       {
74110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74111       };
74112     } catch (...) {
74113       {
74114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74115       };
74116     }
74117   }
74118
74119   jresult = result;
74120   return jresult;
74121 }
74122
74123
74124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
74125   int jresult ;
74126   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74127   int arg2 ;
74128   int arg3 ;
74129   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
74130   bool arg5 ;
74131   int result;
74132
74133   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74134   arg2 = (int)jarg2;
74135   arg3 = (int)jarg3;
74136   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
74137   arg5 = jarg5 ? true : false;
74138   {
74139     try {
74140       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
74141     } catch (std::out_of_range& e) {
74142       {
74143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74144       };
74145     } catch (std::exception& e) {
74146       {
74147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74148       };
74149     } catch (Dali::DaliException e) {
74150       {
74151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74152       };
74153     } catch (...) {
74154       {
74155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74156       };
74157     }
74158   }
74159
74160   jresult = result;
74161   return jresult;
74162 }
74163
74164
74165 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
74166   float jresult ;
74167   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74168   float result;
74169
74170   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74171   {
74172     try {
74173       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
74174     } catch (std::out_of_range& e) {
74175       {
74176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74177       };
74178     } catch (std::exception& e) {
74179       {
74180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74181       };
74182     } catch (Dali::DaliException e) {
74183       {
74184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74185       };
74186     } catch (...) {
74187       {
74188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74189       };
74190     }
74191   }
74192
74193   jresult = result;
74194   return jresult;
74195 }
74196
74197
74198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
74199   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74200   Dali::Actor *arg2 = 0 ;
74201   int arg3 ;
74202   Dali::Vector3 *arg4 = 0 ;
74203   Dali::Actor *arg5 = 0 ;
74204
74205   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74206   arg2 = (Dali::Actor *)jarg2;
74207   if (!arg2) {
74208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
74209     return ;
74210   }
74211   arg3 = (int)jarg3;
74212   arg4 = (Dali::Vector3 *)jarg4;
74213   if (!arg4) {
74214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74215     return ;
74216   }
74217   arg5 = (Dali::Actor *)jarg5;
74218   if (!arg5) {
74219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
74220     return ;
74221   }
74222   {
74223     try {
74224       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
74225     } catch (std::out_of_range& e) {
74226       {
74227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74228       };
74229     } catch (std::exception& e) {
74230       {
74231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74232       };
74233     } catch (Dali::DaliException e) {
74234       {
74235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74236       };
74237     } catch (...) {
74238       {
74239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74240       };
74241     }
74242   }
74243
74244 }
74245
74246
74247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74248   void * jresult ;
74249   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74250   int arg2 ;
74251   float arg3 ;
74252   Dali::Vector3 *arg4 = 0 ;
74253   Dali::Vector3 result;
74254
74255   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74256   arg2 = (int)jarg2;
74257   arg3 = (float)jarg3;
74258   arg4 = (Dali::Vector3 *)jarg4;
74259   if (!arg4) {
74260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74261     return 0;
74262   }
74263   {
74264     try {
74265       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74266     } catch (std::out_of_range& e) {
74267       {
74268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74269       };
74270     } catch (std::exception& e) {
74271       {
74272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74273       };
74274     } catch (Dali::DaliException e) {
74275       {
74276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74277       };
74278     } catch (...) {
74279       {
74280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74281       };
74282     }
74283   }
74284
74285   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74286   return jresult;
74287 }
74288
74289
74290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
74291   void * jresult ;
74292   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
74293   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
74294
74295   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
74296   {
74297     try {
74298       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
74299     } catch (std::out_of_range& e) {
74300       {
74301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74302       };
74303     } catch (std::exception& e) {
74304       {
74305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74306       };
74307     } catch (Dali::DaliException e) {
74308       {
74309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74310       };
74311     } catch (...) {
74312       {
74313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74314       };
74315     }
74316   }
74317
74318   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
74319   return jresult;
74320 }
74321
74322
74323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
74324   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74325
74326   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74327   {
74328     try {
74329       delete arg1;
74330     } catch (std::out_of_range& e) {
74331       {
74332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74333       };
74334     } catch (std::exception& e) {
74335       {
74336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74337       };
74338     } catch (Dali::DaliException e) {
74339       {
74340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74341       };
74342     } catch (...) {
74343       {
74344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74345       };
74346     }
74347   }
74348
74349 }
74350
74351
74352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
74353   unsigned int jresult ;
74354   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74355   unsigned int result;
74356
74357   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74358   {
74359     try {
74360       result = (unsigned int)(arg1)->GetNumberOfItems();
74361     } catch (std::out_of_range& e) {
74362       {
74363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74364       };
74365     } catch (std::exception& e) {
74366       {
74367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74368       };
74369     } catch (Dali::DaliException e) {
74370       {
74371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74372       };
74373     } catch (...) {
74374       {
74375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74376       };
74377     }
74378   }
74379
74380   jresult = result;
74381   return jresult;
74382 }
74383
74384
74385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
74386   void * jresult ;
74387   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74388   unsigned int arg2 ;
74389   Dali::Actor result;
74390
74391   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74392   arg2 = (unsigned int)jarg2;
74393   {
74394     try {
74395       result = (arg1)->NewItem(arg2);
74396     } catch (std::out_of_range& e) {
74397       {
74398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74399       };
74400     } catch (std::exception& e) {
74401       {
74402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74403       };
74404     } catch (Dali::DaliException e) {
74405       {
74406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74407       };
74408     } catch (...) {
74409       {
74410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74411       };
74412     }
74413   }
74414
74415   jresult = new Dali::Actor((const Dali::Actor &)result);
74416   return jresult;
74417 }
74418
74419
74420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
74421   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74422   unsigned int arg2 ;
74423   Dali::Actor arg3 ;
74424   Dali::Actor *argp3 ;
74425
74426   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74427   arg2 = (unsigned int)jarg2;
74428   argp3 = (Dali::Actor *)jarg3;
74429   if (!argp3) {
74430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74431     return ;
74432   }
74433   arg3 = *argp3;
74434   {
74435     try {
74436       (arg1)->ItemReleased(arg2,arg3);
74437     } catch (std::out_of_range& e) {
74438       {
74439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74440       };
74441     } catch (std::exception& e) {
74442       {
74443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74444       };
74445     } catch (Dali::DaliException e) {
74446       {
74447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74448       };
74449     } catch (...) {
74450       {
74451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74452       };
74453     }
74454   }
74455
74456 }
74457
74458
74459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
74460   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
74461   unsigned int arg2 ;
74462   Dali::Actor arg3 ;
74463   Dali::Actor *argp3 ;
74464
74465   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74466   arg2 = (unsigned int)jarg2;
74467   argp3 = (Dali::Actor *)jarg3;
74468   if (!argp3) {
74469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74470     return ;
74471   }
74472   arg3 = *argp3;
74473   {
74474     try {
74475       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
74476     } catch (std::out_of_range& e) {
74477       {
74478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74479       };
74480     } catch (std::exception& e) {
74481       {
74482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74483       };
74484     } catch (Dali::DaliException e) {
74485       {
74486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74487       };
74488     } catch (...) {
74489       {
74490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74491       };
74492     }
74493   }
74494
74495 }
74496
74497
74498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
74499   void * jresult ;
74500   Dali::Toolkit::ItemFactory *result = 0 ;
74501
74502   {
74503     try {
74504       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
74505     } catch (std::out_of_range& e) {
74506       {
74507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74508       };
74509     } catch (std::exception& e) {
74510       {
74511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74512       };
74513     } catch (Dali::DaliException e) {
74514       {
74515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74516       };
74517     } catch (...) {
74518       {
74519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74520       };
74521     }
74522   }
74523
74524   jresult = (void *)result;
74525   return jresult;
74526 }
74527
74528
74529 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) {
74530   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
74531   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
74532   if (director) {
74533     director->swig_connect_director(callback0, callback1, callback2);
74534   }
74535 }
74536
74537
74538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
74539   int jresult ;
74540   int result;
74541
74542   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
74543   jresult = (int)result;
74544   return jresult;
74545 }
74546
74547
74548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
74549   int jresult ;
74550   int result;
74551
74552   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
74553   jresult = (int)result;
74554   return jresult;
74555 }
74556
74557
74558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74559   int jresult ;
74560   int result;
74561
74562   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74563   jresult = (int)result;
74564   return jresult;
74565 }
74566
74567
74568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
74569   int jresult ;
74570   int result;
74571
74572   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
74573   jresult = (int)result;
74574   return jresult;
74575 }
74576
74577
74578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
74579   int jresult ;
74580   int result;
74581
74582   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
74583   jresult = (int)result;
74584   return jresult;
74585 }
74586
74587
74588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
74589   int jresult ;
74590   int result;
74591
74592   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
74593   jresult = (int)result;
74594   return jresult;
74595 }
74596
74597
74598 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
74599   int jresult ;
74600   int result;
74601
74602   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
74603   jresult = (int)result;
74604   return jresult;
74605 }
74606
74607
74608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
74609   int jresult ;
74610   int result;
74611
74612   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
74613   jresult = (int)result;
74614   return jresult;
74615 }
74616
74617
74618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
74619   int jresult ;
74620   int result;
74621
74622   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
74623   jresult = (int)result;
74624   return jresult;
74625 }
74626
74627
74628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
74629   int jresult ;
74630   int result;
74631
74632   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
74633   jresult = (int)result;
74634   return jresult;
74635 }
74636
74637
74638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
74639   int jresult ;
74640   int result;
74641
74642   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
74643   jresult = (int)result;
74644   return jresult;
74645 }
74646
74647
74648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
74649   void * jresult ;
74650   Dali::Toolkit::ItemView::Property *result = 0 ;
74651
74652   {
74653     try {
74654       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
74655     } catch (std::out_of_range& e) {
74656       {
74657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74658       };
74659     } catch (std::exception& e) {
74660       {
74661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74662       };
74663     } catch (Dali::DaliException e) {
74664       {
74665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74666       };
74667     } catch (...) {
74668       {
74669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74670       };
74671     }
74672   }
74673
74674   jresult = (void *)result;
74675   return jresult;
74676 }
74677
74678
74679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
74680   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
74681
74682   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
74683   {
74684     try {
74685       delete arg1;
74686     } catch (std::out_of_range& e) {
74687       {
74688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74689       };
74690     } catch (std::exception& e) {
74691       {
74692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74693       };
74694     } catch (Dali::DaliException e) {
74695       {
74696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74697       };
74698     } catch (...) {
74699       {
74700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74701       };
74702     }
74703   }
74704
74705 }
74706
74707
74708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
74709   void * jresult ;
74710   Dali::Toolkit::ItemView *result = 0 ;
74711
74712   {
74713     try {
74714       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
74715     } catch (std::out_of_range& e) {
74716       {
74717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74718       };
74719     } catch (std::exception& e) {
74720       {
74721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74722       };
74723     } catch (Dali::DaliException e) {
74724       {
74725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74726       };
74727     } catch (...) {
74728       {
74729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74730       };
74731     }
74732   }
74733
74734   jresult = (void *)result;
74735   return jresult;
74736 }
74737
74738
74739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
74740   void * jresult ;
74741   Dali::Toolkit::ItemView *arg1 = 0 ;
74742   Dali::Toolkit::ItemView *result = 0 ;
74743
74744   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74745   if (!arg1) {
74746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74747     return 0;
74748   }
74749   {
74750     try {
74751       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
74752     } catch (std::out_of_range& e) {
74753       {
74754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74755       };
74756     } catch (std::exception& e) {
74757       {
74758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74759       };
74760     } catch (Dali::DaliException e) {
74761       {
74762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74763       };
74764     } catch (...) {
74765       {
74766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74767       };
74768     }
74769   }
74770
74771   jresult = (void *)result;
74772   return jresult;
74773 }
74774
74775
74776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
74777   void * jresult ;
74778   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74779   Dali::Toolkit::ItemView *arg2 = 0 ;
74780   Dali::Toolkit::ItemView *result = 0 ;
74781
74782   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74783   arg2 = (Dali::Toolkit::ItemView *)jarg2;
74784   if (!arg2) {
74785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
74786     return 0;
74787   }
74788   {
74789     try {
74790       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
74791     } catch (std::out_of_range& e) {
74792       {
74793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74794       };
74795     } catch (std::exception& e) {
74796       {
74797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74798       };
74799     } catch (Dali::DaliException e) {
74800       {
74801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74802       };
74803     } catch (...) {
74804       {
74805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74806       };
74807     }
74808   }
74809
74810   jresult = (void *)result;
74811   return jresult;
74812 }
74813
74814
74815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
74816   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74817
74818   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74819   {
74820     try {
74821       delete arg1;
74822     } catch (std::out_of_range& e) {
74823       {
74824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74825       };
74826     } catch (std::exception& e) {
74827       {
74828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74829       };
74830     } catch (Dali::DaliException e) {
74831       {
74832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74833       };
74834     } catch (...) {
74835       {
74836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74837       };
74838     }
74839   }
74840
74841 }
74842
74843
74844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
74845   void * jresult ;
74846   Dali::Toolkit::ItemFactory *arg1 = 0 ;
74847   Dali::Toolkit::ItemView result;
74848
74849   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
74850   if (!arg1) {
74851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
74852     return 0;
74853   }
74854   {
74855     try {
74856       result = Dali::Toolkit::ItemView::New(*arg1);
74857     } catch (std::out_of_range& e) {
74858       {
74859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74860       };
74861     } catch (std::exception& e) {
74862       {
74863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74864       };
74865     } catch (Dali::DaliException e) {
74866       {
74867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74868       };
74869     } catch (...) {
74870       {
74871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74872       };
74873     }
74874   }
74875
74876   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74877   return jresult;
74878 }
74879
74880
74881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
74882   void * jresult ;
74883   Dali::BaseHandle arg1 ;
74884   Dali::BaseHandle *argp1 ;
74885   Dali::Toolkit::ItemView result;
74886
74887   argp1 = (Dali::BaseHandle *)jarg1;
74888   if (!argp1) {
74889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74890     return 0;
74891   }
74892   arg1 = *argp1;
74893   {
74894     try {
74895       result = Dali::Toolkit::ItemView::DownCast(arg1);
74896     } catch (std::out_of_range& e) {
74897       {
74898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74899       };
74900     } catch (std::exception& e) {
74901       {
74902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74903       };
74904     } catch (Dali::DaliException e) {
74905       {
74906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74907       };
74908     } catch (...) {
74909       {
74910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74911       };
74912     }
74913   }
74914
74915   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
74916   return jresult;
74917 }
74918
74919
74920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
74921   unsigned int jresult ;
74922   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74923   unsigned int result;
74924
74925   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74926   {
74927     try {
74928       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
74929     } catch (std::out_of_range& e) {
74930       {
74931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74932       };
74933     } catch (std::exception& e) {
74934       {
74935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74936       };
74937     } catch (Dali::DaliException e) {
74938       {
74939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74940       };
74941     } catch (...) {
74942       {
74943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74944       };
74945     }
74946   }
74947
74948   jresult = result;
74949   return jresult;
74950 }
74951
74952
74953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
74954   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74955   Dali::Toolkit::ItemLayout *arg2 = 0 ;
74956
74957   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74958   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
74959   if (!arg2) {
74960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
74961     return ;
74962   }
74963   {
74964     try {
74965       (arg1)->AddLayout(*arg2);
74966     } catch (std::out_of_range& e) {
74967       {
74968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74969       };
74970     } catch (std::exception& e) {
74971       {
74972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74973       };
74974     } catch (Dali::DaliException e) {
74975       {
74976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74977       };
74978     } catch (...) {
74979       {
74980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74981       };
74982     }
74983   }
74984
74985 }
74986
74987
74988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
74989   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74990   unsigned int arg2 ;
74991
74992   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74993   arg2 = (unsigned int)jarg2;
74994   {
74995     try {
74996       (arg1)->RemoveLayout(arg2);
74997     } catch (std::out_of_range& e) {
74998       {
74999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75000       };
75001     } catch (std::exception& e) {
75002       {
75003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75004       };
75005     } catch (Dali::DaliException e) {
75006       {
75007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75008       };
75009     } catch (...) {
75010       {
75011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75012       };
75013     }
75014   }
75015
75016 }
75017
75018
75019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75020   void * jresult ;
75021   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75022   unsigned int arg2 ;
75023   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75024
75025   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75026   arg2 = (unsigned int)jarg2;
75027   {
75028     try {
75029       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75030     } catch (std::out_of_range& e) {
75031       {
75032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75033       };
75034     } catch (std::exception& e) {
75035       {
75036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75037       };
75038     } catch (Dali::DaliException e) {
75039       {
75040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75041       };
75042     } catch (...) {
75043       {
75044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75045       };
75046     }
75047   }
75048
75049   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75050   return jresult;
75051 }
75052
75053
75054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75055   void * jresult ;
75056   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75057   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75058
75059   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75060   {
75061     try {
75062       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75063     } catch (std::out_of_range& e) {
75064       {
75065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75066       };
75067     } catch (std::exception& e) {
75068       {
75069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75070       };
75071     } catch (Dali::DaliException e) {
75072       {
75073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75074       };
75075     } catch (...) {
75076       {
75077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75078       };
75079     }
75080   }
75081
75082   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75083   return jresult;
75084 }
75085
75086
75087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
75088   float jresult ;
75089   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75090   Dali::Toolkit::ItemId arg2 ;
75091   float result;
75092
75093   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75094   arg2 = (Dali::Toolkit::ItemId)jarg2;
75095   {
75096     try {
75097       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
75098     } catch (std::out_of_range& e) {
75099       {
75100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75101       };
75102     } catch (std::exception& e) {
75103       {
75104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75105       };
75106     } catch (Dali::DaliException e) {
75107       {
75108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75109       };
75110     } catch (...) {
75111       {
75112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75113       };
75114     }
75115   }
75116
75117   jresult = result;
75118   return jresult;
75119 }
75120
75121
75122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
75123   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75124   unsigned int arg2 ;
75125   Dali::Vector3 arg3 ;
75126   float arg4 ;
75127   Dali::Vector3 *argp3 ;
75128
75129   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75130   arg2 = (unsigned int)jarg2;
75131   argp3 = (Dali::Vector3 *)jarg3;
75132   if (!argp3) {
75133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75134     return ;
75135   }
75136   arg3 = *argp3;
75137   arg4 = (float)jarg4;
75138   {
75139     try {
75140       (arg1)->ActivateLayout(arg2,arg3,arg4);
75141     } catch (std::out_of_range& e) {
75142       {
75143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75144       };
75145     } catch (std::exception& e) {
75146       {
75147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75148       };
75149     } catch (Dali::DaliException e) {
75150       {
75151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75152       };
75153     } catch (...) {
75154       {
75155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75156       };
75157     }
75158   }
75159
75160 }
75161
75162
75163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
75164   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75165
75166   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75167   {
75168     try {
75169       (arg1)->DeactivateCurrentLayout();
75170     } catch (std::out_of_range& e) {
75171       {
75172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75173       };
75174     } catch (std::exception& e) {
75175       {
75176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75177       };
75178     } catch (Dali::DaliException e) {
75179       {
75180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75181       };
75182     } catch (...) {
75183       {
75184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75185       };
75186     }
75187   }
75188
75189 }
75190
75191
75192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
75193   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75194   float arg2 ;
75195
75196   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75197   arg2 = (float)jarg2;
75198   {
75199     try {
75200       (arg1)->SetMinimumSwipeSpeed(arg2);
75201     } catch (std::out_of_range& e) {
75202       {
75203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75204       };
75205     } catch (std::exception& e) {
75206       {
75207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75208       };
75209     } catch (Dali::DaliException e) {
75210       {
75211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75212       };
75213     } catch (...) {
75214       {
75215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75216       };
75217     }
75218   }
75219
75220 }
75221
75222
75223 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
75224   float jresult ;
75225   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75226   float result;
75227
75228   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75229   {
75230     try {
75231       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
75232     } catch (std::out_of_range& e) {
75233       {
75234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75235       };
75236     } catch (std::exception& e) {
75237       {
75238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75239       };
75240     } catch (Dali::DaliException e) {
75241       {
75242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75243       };
75244     } catch (...) {
75245       {
75246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75247       };
75248     }
75249   }
75250
75251   jresult = result;
75252   return jresult;
75253 }
75254
75255
75256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
75257   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75258   float arg2 ;
75259
75260   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75261   arg2 = (float)jarg2;
75262   {
75263     try {
75264       (arg1)->SetMinimumSwipeDistance(arg2);
75265     } catch (std::out_of_range& e) {
75266       {
75267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75268       };
75269     } catch (std::exception& e) {
75270       {
75271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75272       };
75273     } catch (Dali::DaliException e) {
75274       {
75275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75276       };
75277     } catch (...) {
75278       {
75279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75280       };
75281     }
75282   }
75283
75284 }
75285
75286
75287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
75288   float jresult ;
75289   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75290   float result;
75291
75292   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75293   {
75294     try {
75295       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
75296     } catch (std::out_of_range& e) {
75297       {
75298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75299       };
75300     } catch (std::exception& e) {
75301       {
75302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75303       };
75304     } catch (Dali::DaliException e) {
75305       {
75306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75307       };
75308     } catch (...) {
75309       {
75310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75311       };
75312     }
75313   }
75314
75315   jresult = result;
75316   return jresult;
75317 }
75318
75319
75320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
75321   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75322   float arg2 ;
75323
75324   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75325   arg2 = (float)jarg2;
75326   {
75327     try {
75328       (arg1)->SetWheelScrollDistanceStep(arg2);
75329     } catch (std::out_of_range& e) {
75330       {
75331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75332       };
75333     } catch (std::exception& e) {
75334       {
75335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75336       };
75337     } catch (Dali::DaliException e) {
75338       {
75339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75340       };
75341     } catch (...) {
75342       {
75343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75344       };
75345     }
75346   }
75347
75348 }
75349
75350
75351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
75352   float jresult ;
75353   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75354   float result;
75355
75356   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75357   {
75358     try {
75359       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
75360     } catch (std::out_of_range& e) {
75361       {
75362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75363       };
75364     } catch (std::exception& e) {
75365       {
75366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75367       };
75368     } catch (Dali::DaliException e) {
75369       {
75370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75371       };
75372     } catch (...) {
75373       {
75374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75375       };
75376     }
75377   }
75378
75379   jresult = result;
75380   return jresult;
75381 }
75382
75383
75384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
75385   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75386   bool arg2 ;
75387
75388   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75389   arg2 = jarg2 ? true : false;
75390   {
75391     try {
75392       (arg1)->SetAnchoring(arg2);
75393     } catch (std::out_of_range& e) {
75394       {
75395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75396       };
75397     } catch (std::exception& e) {
75398       {
75399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75400       };
75401     } catch (Dali::DaliException e) {
75402       {
75403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75404       };
75405     } catch (...) {
75406       {
75407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75408       };
75409     }
75410   }
75411
75412 }
75413
75414 //// ========================= end of part 3 =============================
75415
75416 //// ========================== start part 4 ===============================
75417
75418
75419 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
75420   unsigned int jresult ;
75421   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75422   bool result;
75423
75424   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75425   {
75426     try {
75427       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
75428     } catch (std::out_of_range& e) {
75429       {
75430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75431       };
75432     } catch (std::exception& e) {
75433       {
75434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75435       };
75436     } catch (Dali::DaliException e) {
75437       {
75438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75439       };
75440     } catch (...) {
75441       {
75442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75443       };
75444     }
75445   }
75446
75447   jresult = result;
75448   return jresult;
75449 }
75450
75451
75452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
75453   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75454   float arg2 ;
75455
75456   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75457   arg2 = (float)jarg2;
75458   {
75459     try {
75460       (arg1)->SetAnchoringDuration(arg2);
75461     } catch (std::out_of_range& e) {
75462       {
75463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75464       };
75465     } catch (std::exception& e) {
75466       {
75467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75468       };
75469     } catch (Dali::DaliException e) {
75470       {
75471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75472       };
75473     } catch (...) {
75474       {
75475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75476       };
75477     }
75478   }
75479
75480 }
75481
75482
75483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
75484   float jresult ;
75485   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75486   float result;
75487
75488   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75489   {
75490     try {
75491       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
75492     } catch (std::out_of_range& e) {
75493       {
75494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75495       };
75496     } catch (std::exception& e) {
75497       {
75498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75499       };
75500     } catch (Dali::DaliException e) {
75501       {
75502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75503       };
75504     } catch (...) {
75505       {
75506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75507       };
75508     }
75509   }
75510
75511   jresult = result;
75512   return jresult;
75513 }
75514
75515
75516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
75517   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75518   Dali::Toolkit::ItemId arg2 ;
75519   float arg3 ;
75520
75521   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75522   arg2 = (Dali::Toolkit::ItemId)jarg2;
75523   arg3 = (float)jarg3;
75524   {
75525     try {
75526       (arg1)->ScrollToItem(arg2,arg3);
75527     } catch (std::out_of_range& e) {
75528       {
75529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75530       };
75531     } catch (std::exception& e) {
75532       {
75533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75534       };
75535     } catch (Dali::DaliException e) {
75536       {
75537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75538       };
75539     } catch (...) {
75540       {
75541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75542       };
75543     }
75544   }
75545
75546 }
75547
75548
75549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
75550   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75551   float arg2 ;
75552
75553   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75554   arg2 = (float)jarg2;
75555   {
75556     try {
75557       (arg1)->SetRefreshInterval(arg2);
75558     } catch (std::out_of_range& e) {
75559       {
75560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75561       };
75562     } catch (std::exception& e) {
75563       {
75564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75565       };
75566     } catch (Dali::DaliException e) {
75567       {
75568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75569       };
75570     } catch (...) {
75571       {
75572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75573       };
75574     }
75575   }
75576
75577 }
75578
75579
75580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
75581   float jresult ;
75582   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75583   float result;
75584
75585   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75586   {
75587     try {
75588       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
75589     } catch (std::out_of_range& e) {
75590       {
75591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75592       };
75593     } catch (std::exception& e) {
75594       {
75595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75596       };
75597     } catch (Dali::DaliException e) {
75598       {
75599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75600       };
75601     } catch (...) {
75602       {
75603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75604       };
75605     }
75606   }
75607
75608   jresult = result;
75609   return jresult;
75610 }
75611
75612
75613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
75614   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75615
75616   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75617   {
75618     try {
75619       (arg1)->Refresh();
75620     } catch (std::out_of_range& e) {
75621       {
75622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75623       };
75624     } catch (std::exception& e) {
75625       {
75626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75627       };
75628     } catch (Dali::DaliException e) {
75629       {
75630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75631       };
75632     } catch (...) {
75633       {
75634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75635       };
75636     }
75637   }
75638
75639 }
75640
75641
75642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
75643   void * jresult ;
75644   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75645   Dali::Toolkit::ItemId arg2 ;
75646   Dali::Actor result;
75647
75648   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75649   arg2 = (Dali::Toolkit::ItemId)jarg2;
75650   {
75651     try {
75652       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
75653     } catch (std::out_of_range& e) {
75654       {
75655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75656       };
75657     } catch (std::exception& e) {
75658       {
75659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75660       };
75661     } catch (Dali::DaliException e) {
75662       {
75663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75664       };
75665     } catch (...) {
75666       {
75667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75668       };
75669     }
75670   }
75671
75672   jresult = new Dali::Actor((const Dali::Actor &)result);
75673   return jresult;
75674 }
75675
75676
75677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
75678   unsigned int jresult ;
75679   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75680   Dali::Actor arg2 ;
75681   Dali::Actor *argp2 ;
75682   Dali::Toolkit::ItemId result;
75683
75684   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75685   argp2 = (Dali::Actor *)jarg2;
75686   if (!argp2) {
75687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75688     return 0;
75689   }
75690   arg2 = *argp2;
75691   {
75692     try {
75693       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
75694     } catch (std::out_of_range& e) {
75695       {
75696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75697       };
75698     } catch (std::exception& e) {
75699       {
75700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75701       };
75702     } catch (Dali::DaliException e) {
75703       {
75704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75705       };
75706     } catch (...) {
75707       {
75708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75709       };
75710     }
75711   }
75712
75713   jresult = result;
75714   return jresult;
75715 }
75716
75717
75718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
75719   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75720   Dali::Toolkit::Item arg2 ;
75721   float arg3 ;
75722   Dali::Toolkit::Item *argp2 ;
75723
75724   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75725   argp2 = (Dali::Toolkit::Item *)jarg2;
75726   if (!argp2) {
75727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75728     return ;
75729   }
75730   arg2 = *argp2;
75731   arg3 = (float)jarg3;
75732   {
75733     try {
75734       (arg1)->InsertItem(arg2,arg3);
75735     } catch (std::out_of_range& e) {
75736       {
75737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75738       };
75739     } catch (std::exception& e) {
75740       {
75741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75742       };
75743     } catch (Dali::DaliException e) {
75744       {
75745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75746       };
75747     } catch (...) {
75748       {
75749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75750       };
75751     }
75752   }
75753
75754 }
75755
75756
75757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
75758   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75759   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75760   float arg3 ;
75761
75762   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75763   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75764   if (!arg2) {
75765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75766     return ;
75767   }
75768   arg3 = (float)jarg3;
75769   {
75770     try {
75771       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75772     } catch (std::out_of_range& e) {
75773       {
75774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75775       };
75776     } catch (std::exception& e) {
75777       {
75778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75779       };
75780     } catch (Dali::DaliException e) {
75781       {
75782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75783       };
75784     } catch (...) {
75785       {
75786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75787       };
75788     }
75789   }
75790
75791 }
75792
75793
75794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
75795   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75796   Dali::Toolkit::ItemId arg2 ;
75797   float arg3 ;
75798
75799   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75800   arg2 = (Dali::Toolkit::ItemId)jarg2;
75801   arg3 = (float)jarg3;
75802   {
75803     try {
75804       (arg1)->RemoveItem(arg2,arg3);
75805     } catch (std::out_of_range& e) {
75806       {
75807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75808       };
75809     } catch (std::exception& e) {
75810       {
75811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75812       };
75813     } catch (Dali::DaliException e) {
75814       {
75815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75816       };
75817     } catch (...) {
75818       {
75819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75820       };
75821     }
75822   }
75823
75824 }
75825
75826
75827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
75828   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75829   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
75830   float arg3 ;
75831
75832   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75833   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
75834   if (!arg2) {
75835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
75836     return ;
75837   }
75838   arg3 = (float)jarg3;
75839   {
75840     try {
75841       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
75842     } catch (std::out_of_range& e) {
75843       {
75844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75845       };
75846     } catch (std::exception& e) {
75847       {
75848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75849       };
75850     } catch (Dali::DaliException e) {
75851       {
75852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75853       };
75854     } catch (...) {
75855       {
75856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75857       };
75858     }
75859   }
75860
75861 }
75862
75863
75864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
75865   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75866   Dali::Toolkit::Item arg2 ;
75867   float arg3 ;
75868   Dali::Toolkit::Item *argp2 ;
75869
75870   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75871   argp2 = (Dali::Toolkit::Item *)jarg2;
75872   if (!argp2) {
75873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
75874     return ;
75875   }
75876   arg2 = *argp2;
75877   arg3 = (float)jarg3;
75878   {
75879     try {
75880       (arg1)->ReplaceItem(arg2,arg3);
75881     } catch (std::out_of_range& e) {
75882       {
75883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75884       };
75885     } catch (std::exception& e) {
75886       {
75887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75888       };
75889     } catch (Dali::DaliException e) {
75890       {
75891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75892       };
75893     } catch (...) {
75894       {
75895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75896       };
75897     }
75898   }
75899
75900 }
75901
75902
75903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
75904   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75905   Dali::Toolkit::ItemContainer *arg2 = 0 ;
75906   float arg3 ;
75907
75908   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75909   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
75910   if (!arg2) {
75911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
75912     return ;
75913   }
75914   arg3 = (float)jarg3;
75915   {
75916     try {
75917       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
75918     } catch (std::out_of_range& e) {
75919       {
75920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75921       };
75922     } catch (std::exception& e) {
75923       {
75924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75925       };
75926     } catch (Dali::DaliException e) {
75927       {
75928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75929       };
75930     } catch (...) {
75931       {
75932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75933       };
75934     }
75935   }
75936
75937 }
75938
75939
75940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
75941   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75942   Dali::Vector3 *arg2 = 0 ;
75943
75944   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75945   arg2 = (Dali::Vector3 *)jarg2;
75946   if (!arg2) {
75947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75948     return ;
75949   }
75950   {
75951     try {
75952       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
75953     } catch (std::out_of_range& e) {
75954       {
75955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75956       };
75957     } catch (std::exception& e) {
75958       {
75959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75960       };
75961     } catch (Dali::DaliException e) {
75962       {
75963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75964       };
75965     } catch (...) {
75966       {
75967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75968       };
75969     }
75970   }
75971
75972 }
75973
75974
75975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
75976   void * jresult ;
75977   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75978   Dali::Vector3 result;
75979
75980   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75981   {
75982     try {
75983       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
75984     } catch (std::out_of_range& e) {
75985       {
75986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75987       };
75988     } catch (std::exception& e) {
75989       {
75990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75991       };
75992     } catch (Dali::DaliException e) {
75993       {
75994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75995       };
75996     } catch (...) {
75997       {
75998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75999       };
76000     }
76001   }
76002
76003   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76004   return jresult;
76005 }
76006
76007
76008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76009   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76010   Dali::Vector3 *arg2 = 0 ;
76011
76012   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76013   arg2 = (Dali::Vector3 *)jarg2;
76014   if (!arg2) {
76015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76016     return ;
76017   }
76018   {
76019     try {
76020       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76021     } catch (std::out_of_range& e) {
76022       {
76023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76024       };
76025     } catch (std::exception& e) {
76026       {
76027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76028       };
76029     } catch (Dali::DaliException e) {
76030       {
76031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76032       };
76033     } catch (...) {
76034       {
76035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76036       };
76037     }
76038   }
76039
76040 }
76041
76042
76043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76044   void * jresult ;
76045   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76046   Dali::Vector3 result;
76047
76048   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76049   {
76050     try {
76051       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76052     } catch (std::out_of_range& e) {
76053       {
76054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76055       };
76056     } catch (std::exception& e) {
76057       {
76058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76059       };
76060     } catch (Dali::DaliException e) {
76061       {
76062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76063       };
76064     } catch (...) {
76065       {
76066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76067       };
76068     }
76069   }
76070
76071   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76072   return jresult;
76073 }
76074
76075
76076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
76077   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76078   Dali::Toolkit::ItemRange *arg2 = 0 ;
76079
76080   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76081   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
76082   if (!arg2) {
76083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
76084     return ;
76085   }
76086   {
76087     try {
76088       (arg1)->GetItemsRange(*arg2);
76089     } catch (std::out_of_range& e) {
76090       {
76091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76092       };
76093     } catch (std::exception& e) {
76094       {
76095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76096       };
76097     } catch (Dali::DaliException e) {
76098       {
76099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76100       };
76101     } catch (...) {
76102       {
76103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76104       };
76105     }
76106   }
76107
76108 }
76109
76110
76111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
76112   void * jresult ;
76113   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76114   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
76115
76116   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76117   {
76118     try {
76119       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
76120     } catch (std::out_of_range& e) {
76121       {
76122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76123       };
76124     } catch (std::exception& e) {
76125       {
76126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76127       };
76128     } catch (Dali::DaliException e) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76131       };
76132     } catch (...) {
76133       {
76134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76135       };
76136     }
76137   }
76138
76139   jresult = (void *)result;
76140   return jresult;
76141 }
76142
76143
76144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
76145   Dali::Vector3 *arg1 = 0 ;
76146   PropertyInputContainer *arg2 = 0 ;
76147
76148   arg1 = (Dali::Vector3 *)jarg1;
76149   if (!arg1) {
76150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76151     return ;
76152   }
76153   arg2 = (PropertyInputContainer *)jarg2;
76154   if (!arg2) {
76155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76156     return ;
76157   }
76158   {
76159     try {
76160       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76161     } catch (std::out_of_range& e) {
76162       {
76163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76164       };
76165     } catch (std::exception& e) {
76166       {
76167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76168       };
76169     } catch (Dali::DaliException e) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76172       };
76173     } catch (...) {
76174       {
76175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76176       };
76177     }
76178   }
76179
76180 }
76181
76182
76183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
76184   Dali::Vector3 *arg1 = 0 ;
76185   PropertyInputContainer *arg2 = 0 ;
76186
76187   arg1 = (Dali::Vector3 *)jarg1;
76188   if (!arg1) {
76189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
76190     return ;
76191   }
76192   arg2 = (PropertyInputContainer *)jarg2;
76193   if (!arg2) {
76194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
76195     return ;
76196   }
76197   {
76198     try {
76199       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
76200     } catch (std::out_of_range& e) {
76201       {
76202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76203       };
76204     } catch (std::exception& e) {
76205       {
76206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76207       };
76208     } catch (Dali::DaliException e) {
76209       {
76210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76211       };
76212     } catch (...) {
76213       {
76214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76215       };
76216     }
76217   }
76218
76219 }
76220
76221
76222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
76223   void * jresult ;
76224   Dali::Toolkit::ScrollViewEffect *result = 0 ;
76225
76226   {
76227     try {
76228       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
76229     } catch (std::out_of_range& e) {
76230       {
76231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76232       };
76233     } catch (std::exception& e) {
76234       {
76235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76236       };
76237     } catch (Dali::DaliException e) {
76238       {
76239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76240       };
76241     } catch (...) {
76242       {
76243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76244       };
76245     }
76246   }
76247
76248   jresult = (void *)result;
76249   return jresult;
76250 }
76251
76252
76253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
76254   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
76255
76256   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
76257   {
76258     try {
76259       delete arg1;
76260     } catch (std::out_of_range& e) {
76261       {
76262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76263       };
76264     } catch (std::exception& e) {
76265       {
76266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76267       };
76268     } catch (Dali::DaliException e) {
76269       {
76270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76271       };
76272     } catch (...) {
76273       {
76274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76275       };
76276     }
76277   }
76278
76279 }
76280
76281
76282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
76283   void * jresult ;
76284   Dali::Path arg1 ;
76285   Dali::Vector3 *arg2 = 0 ;
76286   Dali::Property::Index arg3 ;
76287   Dali::Vector3 *arg4 = 0 ;
76288   unsigned int arg5 ;
76289   Dali::Path *argp1 ;
76290   Dali::Toolkit::ScrollViewPagePathEffect result;
76291
76292   argp1 = (Dali::Path *)jarg1;
76293   if (!argp1) {
76294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
76295     return 0;
76296   }
76297   arg1 = *argp1;
76298   arg2 = (Dali::Vector3 *)jarg2;
76299   if (!arg2) {
76300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76301     return 0;
76302   }
76303   arg3 = (Dali::Property::Index)jarg3;
76304   arg4 = (Dali::Vector3 *)jarg4;
76305   if (!arg4) {
76306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76307     return 0;
76308   }
76309   arg5 = (unsigned int)jarg5;
76310   {
76311     try {
76312       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
76313     } catch (std::out_of_range& e) {
76314       {
76315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76316       };
76317     } catch (std::exception& e) {
76318       {
76319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76320       };
76321     } catch (Dali::DaliException e) {
76322       {
76323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76324       };
76325     } catch (...) {
76326       {
76327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76328       };
76329     }
76330   }
76331
76332   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76333   return jresult;
76334 }
76335
76336
76337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
76338   void * jresult ;
76339   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
76340
76341   {
76342     try {
76343       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
76344     } catch (std::out_of_range& e) {
76345       {
76346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76347       };
76348     } catch (std::exception& e) {
76349       {
76350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76351       };
76352     } catch (Dali::DaliException e) {
76353       {
76354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76355       };
76356     } catch (...) {
76357       {
76358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76359       };
76360     }
76361   }
76362
76363   jresult = (void *)result;
76364   return jresult;
76365 }
76366
76367
76368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
76369   void * jresult ;
76370   Dali::BaseHandle arg1 ;
76371   Dali::BaseHandle *argp1 ;
76372   Dali::Toolkit::ScrollViewPagePathEffect result;
76373
76374   argp1 = (Dali::BaseHandle *)jarg1;
76375   if (!argp1) {
76376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76377     return 0;
76378   }
76379   arg1 = *argp1;
76380   {
76381     try {
76382       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
76383     } catch (std::out_of_range& e) {
76384       {
76385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76386       };
76387     } catch (std::exception& e) {
76388       {
76389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76390       };
76391     } catch (Dali::DaliException e) {
76392       {
76393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76394       };
76395     } catch (...) {
76396       {
76397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76398       };
76399     }
76400   }
76401
76402   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
76403   return jresult;
76404 }
76405
76406
76407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
76408   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76409   Dali::Actor arg2 ;
76410   unsigned int arg3 ;
76411   Dali::Actor *argp2 ;
76412
76413   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76414   argp2 = (Dali::Actor *)jarg2;
76415   if (!argp2) {
76416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76417     return ;
76418   }
76419   arg2 = *argp2;
76420   arg3 = (unsigned int)jarg3;
76421   {
76422     try {
76423       (arg1)->ApplyToPage(arg2,arg3);
76424     } catch (std::out_of_range& e) {
76425       {
76426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76427       };
76428     } catch (std::exception& e) {
76429       {
76430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76431       };
76432     } catch (Dali::DaliException e) {
76433       {
76434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76435       };
76436     } catch (...) {
76437       {
76438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76439       };
76440     }
76441   }
76442
76443 }
76444
76445
76446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
76447   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
76448
76449   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
76450   {
76451     try {
76452       delete arg1;
76453     } catch (std::out_of_range& e) {
76454       {
76455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76456       };
76457     } catch (std::exception& e) {
76458       {
76459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76460       };
76461     } catch (Dali::DaliException e) {
76462       {
76463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76464       };
76465     } catch (...) {
76466       {
76467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76468       };
76469     }
76470   }
76471
76472 }
76473
76474
76475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
76476   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76477   Dali::Toolkit::ClampState arg2 ;
76478
76479   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76480   arg2 = (Dali::Toolkit::ClampState)jarg2;
76481   if (arg1) (arg1)->x = arg2;
76482 }
76483
76484
76485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
76486   int jresult ;
76487   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76488   Dali::Toolkit::ClampState result;
76489
76490   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76491   result = (Dali::Toolkit::ClampState) ((arg1)->x);
76492   jresult = (int)result;
76493   return jresult;
76494 }
76495
76496
76497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
76498   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76499   Dali::Toolkit::ClampState arg2 ;
76500
76501   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76502   arg2 = (Dali::Toolkit::ClampState)jarg2;
76503   if (arg1) (arg1)->y = arg2;
76504 }
76505
76506
76507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
76508   int jresult ;
76509   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76510   Dali::Toolkit::ClampState result;
76511
76512   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76513   result = (Dali::Toolkit::ClampState) ((arg1)->y);
76514   jresult = (int)result;
76515   return jresult;
76516 }
76517
76518
76519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
76520   void * jresult ;
76521   Dali::Toolkit::ClampState2D *result = 0 ;
76522
76523   {
76524     try {
76525       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
76526     } catch (std::out_of_range& e) {
76527       {
76528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76529       };
76530     } catch (std::exception& e) {
76531       {
76532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76533       };
76534     } catch (Dali::DaliException e) {
76535       {
76536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76537       };
76538     } catch (...) {
76539       {
76540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76541       };
76542     }
76543   }
76544
76545   jresult = (void *)result;
76546   return jresult;
76547 }
76548
76549
76550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
76551   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
76552
76553   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
76554   {
76555     try {
76556       delete arg1;
76557     } catch (std::out_of_range& e) {
76558       {
76559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76560       };
76561     } catch (std::exception& e) {
76562       {
76563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76564       };
76565     } catch (Dali::DaliException e) {
76566       {
76567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76568       };
76569     } catch (...) {
76570       {
76571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76572       };
76573     }
76574   }
76575
76576 }
76577
76578
76579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
76580   void * jresult ;
76581   float arg1 ;
76582   float arg2 ;
76583   bool arg3 ;
76584   Dali::Toolkit::RulerDomain *result = 0 ;
76585
76586   arg1 = (float)jarg1;
76587   arg2 = (float)jarg2;
76588   arg3 = jarg3 ? true : false;
76589   {
76590     try {
76591       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
76592     } catch (std::out_of_range& e) {
76593       {
76594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76595       };
76596     } catch (std::exception& e) {
76597       {
76598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76599       };
76600     } catch (Dali::DaliException e) {
76601       {
76602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76603       };
76604     } catch (...) {
76605       {
76606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76607       };
76608     }
76609   }
76610
76611   jresult = (void *)result;
76612   return jresult;
76613 }
76614
76615
76616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
76617   void * jresult ;
76618   float arg1 ;
76619   float arg2 ;
76620   Dali::Toolkit::RulerDomain *result = 0 ;
76621
76622   arg1 = (float)jarg1;
76623   arg2 = (float)jarg2;
76624   {
76625     try {
76626       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
76627     } catch (std::out_of_range& e) {
76628       {
76629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76630       };
76631     } catch (std::exception& e) {
76632       {
76633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76634       };
76635     } catch (Dali::DaliException e) {
76636       {
76637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76638       };
76639     } catch (...) {
76640       {
76641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76642       };
76643     }
76644   }
76645
76646   jresult = (void *)result;
76647   return jresult;
76648 }
76649
76650
76651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
76652   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76653   float arg2 ;
76654
76655   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76656   arg2 = (float)jarg2;
76657   if (arg1) (arg1)->min = arg2;
76658 }
76659
76660
76661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
76662   float jresult ;
76663   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76664   float result;
76665
76666   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76667   result = (float) ((arg1)->min);
76668   jresult = result;
76669   return jresult;
76670 }
76671
76672
76673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
76674   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76675   float arg2 ;
76676
76677   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76678   arg2 = (float)jarg2;
76679   if (arg1) (arg1)->max = arg2;
76680 }
76681
76682
76683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
76684   float jresult ;
76685   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76686   float result;
76687
76688   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76689   result = (float) ((arg1)->max);
76690   jresult = result;
76691   return jresult;
76692 }
76693
76694
76695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
76696   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76697   bool arg2 ;
76698
76699   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76700   arg2 = jarg2 ? true : false;
76701   if (arg1) (arg1)->enabled = arg2;
76702 }
76703
76704
76705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
76706   unsigned int jresult ;
76707   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76708   bool result;
76709
76710   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76711   result = (bool) ((arg1)->enabled);
76712   jresult = result;
76713   return jresult;
76714 }
76715
76716
76717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
76718   float jresult ;
76719   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76720   float arg2 ;
76721   float arg3 ;
76722   float arg4 ;
76723   float result;
76724
76725   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76726   arg2 = (float)jarg2;
76727   arg3 = (float)jarg3;
76728   arg4 = (float)jarg4;
76729   {
76730     try {
76731       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
76732     } catch (std::out_of_range& e) {
76733       {
76734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76735       };
76736     } catch (std::exception& e) {
76737       {
76738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76739       };
76740     } catch (Dali::DaliException e) {
76741       {
76742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76743       };
76744     } catch (...) {
76745       {
76746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76747       };
76748     }
76749   }
76750
76751   jresult = result;
76752   return jresult;
76753 }
76754
76755
76756 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
76757   float jresult ;
76758   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76759   float arg2 ;
76760   float arg3 ;
76761   float result;
76762
76763   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76764   arg2 = (float)jarg2;
76765   arg3 = (float)jarg3;
76766   {
76767     try {
76768       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
76769     } catch (std::out_of_range& e) {
76770       {
76771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76772       };
76773     } catch (std::exception& e) {
76774       {
76775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76776       };
76777     } catch (Dali::DaliException e) {
76778       {
76779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76780       };
76781     } catch (...) {
76782       {
76783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76784       };
76785     }
76786   }
76787
76788   jresult = result;
76789   return jresult;
76790 }
76791
76792
76793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
76794   float jresult ;
76795   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76796   float arg2 ;
76797   float result;
76798
76799   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76800   arg2 = (float)jarg2;
76801   {
76802     try {
76803       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
76804     } catch (std::out_of_range& e) {
76805       {
76806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76807       };
76808     } catch (std::exception& e) {
76809       {
76810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76811       };
76812     } catch (Dali::DaliException e) {
76813       {
76814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76815       };
76816     } catch (...) {
76817       {
76818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76819       };
76820     }
76821   }
76822
76823   jresult = result;
76824   return jresult;
76825 }
76826
76827
76828 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
76829   float jresult ;
76830   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76831   float arg2 ;
76832   float arg3 ;
76833   float arg4 ;
76834   Dali::Toolkit::ClampState *arg5 = 0 ;
76835   float result;
76836
76837   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76838   arg2 = (float)jarg2;
76839   arg3 = (float)jarg3;
76840   arg4 = (float)jarg4;
76841   arg5 = (Dali::Toolkit::ClampState *)jarg5;
76842   if (!arg5) {
76843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76844     return 0;
76845   }
76846   {
76847     try {
76848       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
76849     } catch (std::out_of_range& e) {
76850       {
76851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76852       };
76853     } catch (std::exception& e) {
76854       {
76855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76856       };
76857     } catch (Dali::DaliException e) {
76858       {
76859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76860       };
76861     } catch (...) {
76862       {
76863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76864       };
76865     }
76866   }
76867
76868   jresult = result;
76869   return jresult;
76870 }
76871
76872
76873 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
76874   float jresult ;
76875   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76876   float result;
76877
76878   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76879   {
76880     try {
76881       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
76882     } catch (std::out_of_range& e) {
76883       {
76884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76885       };
76886     } catch (std::exception& e) {
76887       {
76888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76889       };
76890     } catch (Dali::DaliException e) {
76891       {
76892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76893       };
76894     } catch (...) {
76895       {
76896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76897       };
76898     }
76899   }
76900
76901   jresult = result;
76902   return jresult;
76903 }
76904
76905
76906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
76907   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
76908
76909   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
76910   {
76911     try {
76912       delete arg1;
76913     } catch (std::out_of_range& e) {
76914       {
76915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76916       };
76917     } catch (std::exception& e) {
76918       {
76919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76920       };
76921     } catch (Dali::DaliException e) {
76922       {
76923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76924       };
76925     } catch (...) {
76926       {
76927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76928       };
76929     }
76930   }
76931
76932 }
76933
76934
76935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
76936   float jresult ;
76937   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76938   float arg2 ;
76939   float arg3 ;
76940   float result;
76941
76942   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76943   arg2 = (float)jarg2;
76944   arg3 = (float)jarg3;
76945   {
76946     try {
76947       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
76948     } catch (std::out_of_range& e) {
76949       {
76950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76951       };
76952     } catch (std::exception& e) {
76953       {
76954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76955       };
76956     } catch (Dali::DaliException e) {
76957       {
76958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76959       };
76960     } catch (...) {
76961       {
76962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76963       };
76964     }
76965   }
76966
76967   jresult = result;
76968   return jresult;
76969 }
76970
76971
76972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
76973   float jresult ;
76974   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76975   float arg2 ;
76976   float result;
76977
76978   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76979   arg2 = (float)jarg2;
76980   {
76981     try {
76982       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
76983     } catch (std::out_of_range& e) {
76984       {
76985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76986       };
76987     } catch (std::exception& e) {
76988       {
76989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76990       };
76991     } catch (Dali::DaliException e) {
76992       {
76993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76994       };
76995     } catch (...) {
76996       {
76997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76998       };
76999     }
77000   }
77001
77002   jresult = result;
77003   return jresult;
77004 }
77005
77006
77007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77008   float jresult ;
77009   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77010   unsigned int arg2 ;
77011   unsigned int *arg3 = 0 ;
77012   bool arg4 ;
77013   float result;
77014
77015   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77016   arg2 = (unsigned int)jarg2;
77017   arg3 = (unsigned int *)jarg3;
77018   arg4 = jarg4 ? true : false;
77019   {
77020     try {
77021       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77022     } catch (std::out_of_range& e) {
77023       {
77024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77025       };
77026     } catch (std::exception& e) {
77027       {
77028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77029       };
77030     } catch (Dali::DaliException e) {
77031       {
77032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77033       };
77034     } catch (...) {
77035       {
77036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77037       };
77038     }
77039   }
77040
77041   jresult = result;
77042   return jresult;
77043 }
77044
77045
77046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77047   unsigned int jresult ;
77048   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77049   float arg2 ;
77050   bool arg3 ;
77051   unsigned int result;
77052
77053   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77054   arg2 = (float)jarg2;
77055   arg3 = jarg3 ? true : false;
77056   {
77057     try {
77058       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77059     } catch (std::out_of_range& e) {
77060       {
77061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77062       };
77063     } catch (std::exception& e) {
77064       {
77065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77066       };
77067     } catch (Dali::DaliException e) {
77068       {
77069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77070       };
77071     } catch (...) {
77072       {
77073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77074       };
77075     }
77076   }
77077
77078   jresult = result;
77079   return jresult;
77080 }
77081
77082
77083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
77084   unsigned int jresult ;
77085   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77086   unsigned int result;
77087
77088   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77089   {
77090     try {
77091       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
77092     } catch (std::out_of_range& e) {
77093       {
77094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77095       };
77096     } catch (std::exception& e) {
77097       {
77098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77099       };
77100     } catch (Dali::DaliException e) {
77101       {
77102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77103       };
77104     } catch (...) {
77105       {
77106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77107       };
77108     }
77109   }
77110
77111   jresult = result;
77112   return jresult;
77113 }
77114
77115
77116 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
77117   int jresult ;
77118   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77119   Dali::Toolkit::Ruler::RulerType result;
77120
77121   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77122   {
77123     try {
77124       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
77125     } catch (std::out_of_range& e) {
77126       {
77127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77128       };
77129     } catch (std::exception& e) {
77130       {
77131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77132       };
77133     } catch (Dali::DaliException e) {
77134       {
77135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77136       };
77137     } catch (...) {
77138       {
77139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77140       };
77141     }
77142   }
77143
77144   jresult = (int)result;
77145   return jresult;
77146 }
77147
77148
77149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
77150   unsigned int jresult ;
77151   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77152   bool result;
77153
77154   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77155   {
77156     try {
77157       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
77158     } catch (std::out_of_range& e) {
77159       {
77160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77161       };
77162     } catch (std::exception& e) {
77163       {
77164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77165       };
77166     } catch (Dali::DaliException e) {
77167       {
77168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77169       };
77170     } catch (...) {
77171       {
77172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77173       };
77174     }
77175   }
77176
77177   jresult = result;
77178   return jresult;
77179 }
77180
77181
77182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
77183   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77184
77185   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77186   {
77187     try {
77188       (arg1)->Enable();
77189     } catch (std::out_of_range& e) {
77190       {
77191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77192       };
77193     } catch (std::exception& e) {
77194       {
77195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77196       };
77197     } catch (Dali::DaliException e) {
77198       {
77199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77200       };
77201     } catch (...) {
77202       {
77203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77204       };
77205     }
77206   }
77207
77208 }
77209
77210
77211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
77212   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77213
77214   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77215   {
77216     try {
77217       (arg1)->Disable();
77218     } catch (std::out_of_range& e) {
77219       {
77220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77221       };
77222     } catch (std::exception& e) {
77223       {
77224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77225       };
77226     } catch (Dali::DaliException e) {
77227       {
77228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77229       };
77230     } catch (...) {
77231       {
77232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77233       };
77234     }
77235   }
77236
77237 }
77238
77239
77240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
77241   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77242   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
77243   Dali::Toolkit::RulerDomain *argp2 ;
77244
77245   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77246   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
77247   if (!argp2) {
77248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
77249     return ;
77250   }
77251   arg2 = *argp2;
77252   {
77253     try {
77254       (arg1)->SetDomain(arg2);
77255     } catch (std::out_of_range& e) {
77256       {
77257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77258       };
77259     } catch (std::exception& e) {
77260       {
77261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77262       };
77263     } catch (Dali::DaliException e) {
77264       {
77265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77266       };
77267     } catch (...) {
77268       {
77269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77270       };
77271     }
77272   }
77273
77274 }
77275
77276
77277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
77278   void * jresult ;
77279   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77280   Dali::Toolkit::RulerDomain *result = 0 ;
77281
77282   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77283   {
77284     try {
77285       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
77286     } catch (std::out_of_range& e) {
77287       {
77288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77289       };
77290     } catch (std::exception& e) {
77291       {
77292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77293       };
77294     } catch (Dali::DaliException e) {
77295       {
77296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77297       };
77298     } catch (...) {
77299       {
77300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77301       };
77302     }
77303   }
77304
77305   jresult = (void *)result;
77306   return jresult;
77307 }
77308
77309
77310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
77311   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77312
77313   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77314   {
77315     try {
77316       (arg1)->DisableDomain();
77317     } catch (std::out_of_range& e) {
77318       {
77319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77320       };
77321     } catch (std::exception& e) {
77322       {
77323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77324       };
77325     } catch (Dali::DaliException e) {
77326       {
77327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77328       };
77329     } catch (...) {
77330       {
77331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77332       };
77333     }
77334   }
77335
77336 }
77337
77338
77339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77340   float jresult ;
77341   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77342   float arg2 ;
77343   float arg3 ;
77344   float arg4 ;
77345   float result;
77346
77347   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77348   arg2 = (float)jarg2;
77349   arg3 = (float)jarg3;
77350   arg4 = (float)jarg4;
77351   {
77352     try {
77353       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
77354     } catch (std::out_of_range& e) {
77355       {
77356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77357       };
77358     } catch (std::exception& e) {
77359       {
77360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77361       };
77362     } catch (Dali::DaliException e) {
77363       {
77364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77365       };
77366     } catch (...) {
77367       {
77368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77369       };
77370     }
77371   }
77372
77373   jresult = result;
77374   return jresult;
77375 }
77376
77377
77378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77379   float jresult ;
77380   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77381   float arg2 ;
77382   float arg3 ;
77383   float result;
77384
77385   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77386   arg2 = (float)jarg2;
77387   arg3 = (float)jarg3;
77388   {
77389     try {
77390       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
77391     } catch (std::out_of_range& e) {
77392       {
77393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77394       };
77395     } catch (std::exception& e) {
77396       {
77397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77398       };
77399     } catch (Dali::DaliException e) {
77400       {
77401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77402       };
77403     } catch (...) {
77404       {
77405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77406       };
77407     }
77408   }
77409
77410   jresult = result;
77411   return jresult;
77412 }
77413
77414
77415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
77416   float jresult ;
77417   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77418   float arg2 ;
77419   float result;
77420
77421   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77422   arg2 = (float)jarg2;
77423   {
77424     try {
77425       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
77426     } catch (std::out_of_range& e) {
77427       {
77428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77429       };
77430     } catch (std::exception& e) {
77431       {
77432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77433       };
77434     } catch (Dali::DaliException e) {
77435       {
77436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77437       };
77438     } catch (...) {
77439       {
77440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77441       };
77442     }
77443   }
77444
77445   jresult = result;
77446   return jresult;
77447 }
77448
77449
77450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77451   float jresult ;
77452   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77453   float arg2 ;
77454   float arg3 ;
77455   float arg4 ;
77456   Dali::Toolkit::ClampState *arg5 = 0 ;
77457   float result;
77458
77459   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77460   arg2 = (float)jarg2;
77461   arg3 = (float)jarg3;
77462   arg4 = (float)jarg4;
77463   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77464   if (!arg5) {
77465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77466     return 0;
77467   }
77468   {
77469     try {
77470       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77471     } catch (std::out_of_range& e) {
77472       {
77473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77474       };
77475     } catch (std::exception& e) {
77476       {
77477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77478       };
77479     } catch (Dali::DaliException e) {
77480       {
77481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77482       };
77483     } catch (...) {
77484       {
77485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77486       };
77487     }
77488   }
77489
77490   jresult = result;
77491   return jresult;
77492 }
77493
77494
77495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
77496   float jresult ;
77497   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77498   float arg2 ;
77499   float arg3 ;
77500   float arg4 ;
77501   float arg5 ;
77502   float result;
77503
77504   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77505   arg2 = (float)jarg2;
77506   arg3 = (float)jarg3;
77507   arg4 = (float)jarg4;
77508   arg5 = (float)jarg5;
77509   {
77510     try {
77511       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
77512     } catch (std::out_of_range& e) {
77513       {
77514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77515       };
77516     } catch (std::exception& e) {
77517       {
77518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77519       };
77520     } catch (Dali::DaliException e) {
77521       {
77522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77523       };
77524     } catch (...) {
77525       {
77526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77527       };
77528     }
77529   }
77530
77531   jresult = result;
77532   return jresult;
77533 }
77534
77535
77536 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
77537   float jresult ;
77538   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77539   float arg2 ;
77540   float arg3 ;
77541   float arg4 ;
77542   float result;
77543
77544   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77545   arg2 = (float)jarg2;
77546   arg3 = (float)jarg3;
77547   arg4 = (float)jarg4;
77548   {
77549     try {
77550       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
77551     } catch (std::out_of_range& e) {
77552       {
77553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77554       };
77555     } catch (std::exception& e) {
77556       {
77557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77558       };
77559     } catch (Dali::DaliException e) {
77560       {
77561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77562       };
77563     } catch (...) {
77564       {
77565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77566       };
77567     }
77568   }
77569
77570   jresult = result;
77571   return jresult;
77572 }
77573
77574
77575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
77576   float jresult ;
77577   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77578   float arg2 ;
77579   float arg3 ;
77580   float result;
77581
77582   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77583   arg2 = (float)jarg2;
77584   arg3 = (float)jarg3;
77585   {
77586     try {
77587       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
77588     } catch (std::out_of_range& e) {
77589       {
77590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77591       };
77592     } catch (std::exception& e) {
77593       {
77594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77595       };
77596     } catch (Dali::DaliException e) {
77597       {
77598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77599       };
77600     } catch (...) {
77601       {
77602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77603       };
77604     }
77605   }
77606
77607   jresult = result;
77608   return jresult;
77609 }
77610
77611
77612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
77613   float jresult ;
77614   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77615   float arg2 ;
77616   float result;
77617
77618   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77619   arg2 = (float)jarg2;
77620   {
77621     try {
77622       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
77623     } catch (std::out_of_range& e) {
77624       {
77625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77626       };
77627     } catch (std::exception& e) {
77628       {
77629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77630       };
77631     } catch (Dali::DaliException e) {
77632       {
77633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77634       };
77635     } catch (...) {
77636       {
77637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77638       };
77639     }
77640   }
77641
77642   jresult = result;
77643   return jresult;
77644 }
77645
77646
77647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
77648   float jresult ;
77649   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77650   float arg2 ;
77651   float arg3 ;
77652   float arg4 ;
77653   float arg5 ;
77654   Dali::Toolkit::ClampState *arg6 = 0 ;
77655   float result;
77656
77657   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77658   arg2 = (float)jarg2;
77659   arg3 = (float)jarg3;
77660   arg4 = (float)jarg4;
77661   arg5 = (float)jarg5;
77662   arg6 = (Dali::Toolkit::ClampState *)jarg6;
77663   if (!arg6) {
77664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77665     return 0;
77666   }
77667   {
77668     try {
77669       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
77670     } catch (std::out_of_range& e) {
77671       {
77672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77673       };
77674     } catch (std::exception& e) {
77675       {
77676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77677       };
77678     } catch (Dali::DaliException e) {
77679       {
77680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77681       };
77682     } catch (...) {
77683       {
77684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77685       };
77686     }
77687   }
77688
77689   jresult = result;
77690   return jresult;
77691 }
77692
77693
77694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
77695   void * jresult ;
77696   Dali::Toolkit::DefaultRuler *result = 0 ;
77697
77698   {
77699     try {
77700       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
77701     } catch (std::out_of_range& e) {
77702       {
77703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77704       };
77705     } catch (std::exception& e) {
77706       {
77707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77708       };
77709     } catch (Dali::DaliException e) {
77710       {
77711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77712       };
77713     } catch (...) {
77714       {
77715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77716       };
77717     }
77718   }
77719
77720   jresult = (void *)result;
77721   return jresult;
77722 }
77723
77724
77725 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77726   float jresult ;
77727   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77728   float arg2 ;
77729   float arg3 ;
77730   float result;
77731
77732   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77733   arg2 = (float)jarg2;
77734   arg3 = (float)jarg3;
77735   {
77736     try {
77737       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
77738     } catch (std::out_of_range& e) {
77739       {
77740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77741       };
77742     } catch (std::exception& e) {
77743       {
77744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77745       };
77746     } catch (Dali::DaliException e) {
77747       {
77748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77749       };
77750     } catch (...) {
77751       {
77752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77753       };
77754     }
77755   }
77756
77757   jresult = result;
77758   return jresult;
77759 }
77760
77761
77762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77763   float jresult ;
77764   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77765   unsigned int arg2 ;
77766   unsigned int *arg3 = 0 ;
77767   bool arg4 ;
77768   float result;
77769
77770   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77771   arg2 = (unsigned int)jarg2;
77772   arg3 = (unsigned int *)jarg3;
77773   arg4 = jarg4 ? true : false;
77774   {
77775     try {
77776       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77777     } catch (std::out_of_range& e) {
77778       {
77779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77780       };
77781     } catch (std::exception& e) {
77782       {
77783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77784       };
77785     } catch (Dali::DaliException e) {
77786       {
77787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77788       };
77789     } catch (...) {
77790       {
77791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77792       };
77793     }
77794   }
77795
77796   jresult = result;
77797   return jresult;
77798 }
77799
77800
77801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77802   unsigned int jresult ;
77803   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77804   float arg2 ;
77805   bool arg3 ;
77806   unsigned int result;
77807
77808   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77809   arg2 = (float)jarg2;
77810   arg3 = jarg3 ? true : false;
77811   {
77812     try {
77813       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
77814     } catch (std::out_of_range& e) {
77815       {
77816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77817       };
77818     } catch (std::exception& e) {
77819       {
77820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77821       };
77822     } catch (Dali::DaliException e) {
77823       {
77824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77825       };
77826     } catch (...) {
77827       {
77828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77829       };
77830     }
77831   }
77832
77833   jresult = result;
77834   return jresult;
77835 }
77836
77837
77838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
77839   unsigned int jresult ;
77840   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77841   unsigned int result;
77842
77843   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77844   {
77845     try {
77846       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
77847     } catch (std::out_of_range& e) {
77848       {
77849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77850       };
77851     } catch (std::exception& e) {
77852       {
77853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77854       };
77855     } catch (Dali::DaliException e) {
77856       {
77857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77858       };
77859     } catch (...) {
77860       {
77861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77862       };
77863     }
77864   }
77865
77866   jresult = result;
77867   return jresult;
77868 }
77869
77870
77871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
77872   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
77873
77874   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
77875   {
77876     try {
77877       delete arg1;
77878     } catch (std::out_of_range& e) {
77879       {
77880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77881       };
77882     } catch (std::exception& e) {
77883       {
77884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77885       };
77886     } catch (Dali::DaliException e) {
77887       {
77888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77889       };
77890     } catch (...) {
77891       {
77892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77893       };
77894     }
77895   }
77896
77897 }
77898
77899
77900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
77901   void * jresult ;
77902   float arg1 ;
77903   Dali::Toolkit::FixedRuler *result = 0 ;
77904
77905   arg1 = (float)jarg1;
77906   {
77907     try {
77908       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
77909     } catch (std::out_of_range& e) {
77910       {
77911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77912       };
77913     } catch (std::exception& e) {
77914       {
77915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77916       };
77917     } catch (Dali::DaliException e) {
77918       {
77919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77920       };
77921     } catch (...) {
77922       {
77923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77924       };
77925     }
77926   }
77927
77928   jresult = (void *)result;
77929   return jresult;
77930 }
77931
77932
77933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
77934   void * jresult ;
77935   Dali::Toolkit::FixedRuler *result = 0 ;
77936
77937   {
77938     try {
77939       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
77940     } catch (std::out_of_range& e) {
77941       {
77942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77943       };
77944     } catch (std::exception& e) {
77945       {
77946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77947       };
77948     } catch (Dali::DaliException e) {
77949       {
77950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77951       };
77952     } catch (...) {
77953       {
77954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77955       };
77956     }
77957   }
77958
77959   jresult = (void *)result;
77960   return jresult;
77961 }
77962
77963
77964 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
77965   float jresult ;
77966   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
77967   float arg2 ;
77968   float arg3 ;
77969   float result;
77970
77971   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
77972   arg2 = (float)jarg2;
77973   arg3 = (float)jarg3;
77974   {
77975     try {
77976       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
77977     } catch (std::out_of_range& e) {
77978       {
77979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77980       };
77981     } catch (std::exception& e) {
77982       {
77983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77984       };
77985     } catch (Dali::DaliException e) {
77986       {
77987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77988       };
77989     } catch (...) {
77990       {
77991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77992       };
77993     }
77994   }
77995
77996   jresult = result;
77997   return jresult;
77998 }
77999
78000
78001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78002   float jresult ;
78003   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78004   unsigned int arg2 ;
78005   unsigned int *arg3 = 0 ;
78006   bool arg4 ;
78007   float result;
78008
78009   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78010   arg2 = (unsigned int)jarg2;
78011   arg3 = (unsigned int *)jarg3;
78012   arg4 = jarg4 ? true : false;
78013   {
78014     try {
78015       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78016     } catch (std::out_of_range& e) {
78017       {
78018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78019       };
78020     } catch (std::exception& e) {
78021       {
78022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78023       };
78024     } catch (Dali::DaliException e) {
78025       {
78026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78027       };
78028     } catch (...) {
78029       {
78030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78031       };
78032     }
78033   }
78034
78035   jresult = result;
78036   return jresult;
78037 }
78038
78039
78040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78041   unsigned int jresult ;
78042   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78043   float arg2 ;
78044   bool arg3 ;
78045   unsigned int result;
78046
78047   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78048   arg2 = (float)jarg2;
78049   arg3 = jarg3 ? true : false;
78050   {
78051     try {
78052       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78053     } catch (std::out_of_range& e) {
78054       {
78055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78056       };
78057     } catch (std::exception& e) {
78058       {
78059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78060       };
78061     } catch (Dali::DaliException e) {
78062       {
78063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78064       };
78065     } catch (...) {
78066       {
78067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78068       };
78069     }
78070   }
78071
78072   jresult = result;
78073   return jresult;
78074 }
78075
78076
78077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
78078   unsigned int jresult ;
78079   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78080   unsigned int result;
78081
78082   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78083   {
78084     try {
78085       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
78086     } catch (std::out_of_range& e) {
78087       {
78088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78089       };
78090     } catch (std::exception& e) {
78091       {
78092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78093       };
78094     } catch (Dali::DaliException e) {
78095       {
78096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78097       };
78098     } catch (...) {
78099       {
78100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78101       };
78102     }
78103   }
78104
78105   jresult = result;
78106   return jresult;
78107 }
78108
78109
78110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
78111   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78112
78113   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78114   {
78115     try {
78116       delete arg1;
78117     } catch (std::out_of_range& e) {
78118       {
78119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78120       };
78121     } catch (std::exception& e) {
78122       {
78123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78124       };
78125     } catch (Dali::DaliException e) {
78126       {
78127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78128       };
78129     } catch (...) {
78130       {
78131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78132       };
78133     }
78134   }
78135
78136 }
78137
78138
78139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
78140   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78141   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78142
78143   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78144   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78145   if (arg1) (arg1)->scale = *arg2;
78146 }
78147
78148
78149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
78150   void * jresult ;
78151   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78152   Dali::Toolkit::ClampState2D *result = 0 ;
78153
78154   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78155   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
78156   jresult = (void *)result;
78157   return jresult;
78158 }
78159
78160
78161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
78162   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78163   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
78164
78165   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78166   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
78167   if (arg1) (arg1)->position = *arg2;
78168 }
78169
78170
78171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
78172   void * jresult ;
78173   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78174   Dali::Toolkit::ClampState2D *result = 0 ;
78175
78176   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78177   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
78178   jresult = (void *)result;
78179   return jresult;
78180 }
78181
78182
78183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
78184   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78185   Dali::Toolkit::ClampState arg2 ;
78186
78187   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78188   arg2 = (Dali::Toolkit::ClampState)jarg2;
78189   if (arg1) (arg1)->rotation = arg2;
78190 }
78191
78192
78193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
78194   int jresult ;
78195   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78196   Dali::Toolkit::ClampState result;
78197
78198   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78199   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
78200   jresult = (int)result;
78201   return jresult;
78202 }
78203
78204
78205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
78206   void * jresult ;
78207   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
78208
78209   {
78210     try {
78211       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
78212     } catch (std::out_of_range& e) {
78213       {
78214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78215       };
78216     } catch (std::exception& e) {
78217       {
78218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78219       };
78220     } catch (Dali::DaliException e) {
78221       {
78222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78223       };
78224     } catch (...) {
78225       {
78226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78227       };
78228     }
78229   }
78230
78231   jresult = (void *)result;
78232   return jresult;
78233 }
78234
78235
78236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
78237   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
78238
78239   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
78240   {
78241     try {
78242       delete arg1;
78243     } catch (std::out_of_range& e) {
78244       {
78245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78246       };
78247     } catch (std::exception& e) {
78248       {
78249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78250       };
78251     } catch (Dali::DaliException e) {
78252       {
78253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78254       };
78255     } catch (...) {
78256       {
78257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78258       };
78259     }
78260   }
78261
78262 }
78263
78264
78265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
78266   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78267   Dali::Toolkit::SnapType arg2 ;
78268
78269   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78270   arg2 = (Dali::Toolkit::SnapType)jarg2;
78271   if (arg1) (arg1)->type = arg2;
78272 }
78273
78274
78275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
78276   int jresult ;
78277   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78278   Dali::Toolkit::SnapType result;
78279
78280   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78281   result = (Dali::Toolkit::SnapType) ((arg1)->type);
78282   jresult = (int)result;
78283   return jresult;
78284 }
78285
78286
78287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
78288   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78289   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
78290
78291   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78292   arg2 = (Dali::Vector2 *)jarg2;
78293   if (arg1) (arg1)->position = *arg2;
78294 }
78295
78296
78297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
78298   void * jresult ;
78299   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78300   Dali::Vector2 *result = 0 ;
78301
78302   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78303   result = (Dali::Vector2 *)& ((arg1)->position);
78304   jresult = (void *)result;
78305   return jresult;
78306 }
78307
78308
78309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
78310   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78311   float arg2 ;
78312
78313   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78314   arg2 = (float)jarg2;
78315   if (arg1) (arg1)->duration = arg2;
78316 }
78317
78318
78319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
78320   float jresult ;
78321   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78322   float result;
78323
78324   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78325   result = (float) ((arg1)->duration);
78326   jresult = result;
78327   return jresult;
78328 }
78329
78330
78331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
78332   void * jresult ;
78333   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
78334
78335   {
78336     try {
78337       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
78338     } catch (std::out_of_range& e) {
78339       {
78340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78341       };
78342     } catch (std::exception& e) {
78343       {
78344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78345       };
78346     } catch (Dali::DaliException e) {
78347       {
78348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78349       };
78350     } catch (...) {
78351       {
78352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78353       };
78354     }
78355   }
78356
78357   jresult = (void *)result;
78358   return jresult;
78359 }
78360
78361
78362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
78363   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
78364
78365   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
78366   {
78367     try {
78368       delete arg1;
78369     } catch (std::out_of_range& e) {
78370       {
78371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78372       };
78373     } catch (std::exception& e) {
78374       {
78375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78376       };
78377     } catch (Dali::DaliException e) {
78378       {
78379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78380       };
78381     } catch (...) {
78382       {
78383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78384       };
78385     }
78386   }
78387
78388 }
78389
78390
78391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
78392   int jresult ;
78393   int result;
78394
78395   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
78396   jresult = (int)result;
78397   return jresult;
78398 }
78399
78400
78401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
78402   int jresult ;
78403   int result;
78404
78405   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
78406   jresult = (int)result;
78407   return jresult;
78408 }
78409
78410
78411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
78412   int jresult ;
78413   int result;
78414
78415   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
78416   jresult = (int)result;
78417   return jresult;
78418 }
78419
78420
78421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
78422   int jresult ;
78423   int result;
78424
78425   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
78426   jresult = (int)result;
78427   return jresult;
78428 }
78429
78430
78431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
78432   int jresult ;
78433   int result;
78434
78435   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
78436   jresult = (int)result;
78437   return jresult;
78438 }
78439
78440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
78441   int jresult ;
78442   int result;
78443
78444   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
78445   jresult = (int)result;
78446   return jresult;
78447 }
78448
78449
78450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
78451   int jresult ;
78452   int result;
78453
78454   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
78455   jresult = (int)result;
78456   return jresult;
78457 }
78458
78459
78460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
78461   int jresult ;
78462   int result;
78463
78464   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
78465   jresult = (int)result;
78466   return jresult;
78467 }
78468
78469
78470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
78471   int jresult ;
78472   int result;
78473
78474   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
78475   jresult = (int)result;
78476   return jresult;
78477 }
78478
78479
78480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
78481   int jresult ;
78482   int result;
78483
78484   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
78485   jresult = (int)result;
78486   return jresult;
78487 }
78488
78489
78490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
78491   int jresult ;
78492   int result;
78493
78494   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
78495   jresult = (int)result;
78496   return jresult;
78497 }
78498
78499
78500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
78501   int jresult ;
78502   int result;
78503
78504   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
78505   jresult = (int)result;
78506   return jresult;
78507 }
78508
78509
78510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
78511   int jresult ;
78512   int result;
78513
78514   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
78515   jresult = (int)result;
78516   return jresult;
78517 }
78518
78519
78520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
78521   int jresult ;
78522   int result;
78523
78524   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
78525   jresult = (int)result;
78526   return jresult;
78527 }
78528
78529
78530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
78531   int jresult ;
78532   int result;
78533
78534   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
78535   jresult = (int)result;
78536   return jresult;
78537 }
78538
78539
78540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
78541   int jresult ;
78542   int result;
78543
78544   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
78545   jresult = (int)result;
78546   return jresult;
78547 }
78548
78549
78550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
78551   int jresult ;
78552   int result;
78553
78554   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
78555   jresult = (int)result;
78556   return jresult;
78557 }
78558
78559
78560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
78561   int jresult ;
78562   int result;
78563
78564   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
78565   jresult = (int)result;
78566   return jresult;
78567 }
78568
78569
78570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
78571   int jresult ;
78572   int result;
78573
78574   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
78575   jresult = (int)result;
78576   return jresult;
78577 }
78578
78579
78580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
78581   int jresult ;
78582   int result;
78583
78584   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
78585   jresult = (int)result;
78586   return jresult;
78587 }
78588
78589
78590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
78591   int jresult ;
78592   int result;
78593
78594   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
78595   jresult = (int)result;
78596   return jresult;
78597 }
78598
78599
78600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
78601   int jresult ;
78602   int result;
78603
78604   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
78605   jresult = (int)result;
78606   return jresult;
78607 }
78608
78609
78610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
78611   int jresult ;
78612   int result;
78613
78614   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
78615   jresult = (int)result;
78616   return jresult;
78617 }
78618
78619
78620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
78621   int jresult ;
78622   int result;
78623
78624   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
78625   jresult = (int)result;
78626   return jresult;
78627 }
78628
78629
78630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
78631   int jresult ;
78632   int result;
78633
78634   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
78635   jresult = (int)result;
78636   return jresult;
78637 }
78638
78639
78640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
78641   int jresult ;
78642   int result;
78643
78644   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
78645   jresult = (int)result;
78646   return jresult;
78647 }
78648
78649
78650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
78651   void * jresult ;
78652   Dali::Toolkit::ScrollView::Property *result = 0 ;
78653
78654   {
78655     try {
78656       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
78657     } catch (std::out_of_range& e) {
78658       {
78659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78660       };
78661     } catch (std::exception& e) {
78662       {
78663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78664       };
78665     } catch (Dali::DaliException e) {
78666       {
78667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78668       };
78669     } catch (...) {
78670       {
78671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78672       };
78673     }
78674   }
78675
78676   jresult = (void *)result;
78677   return jresult;
78678 }
78679
78680
78681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
78682   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
78683
78684   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
78685   {
78686     try {
78687       delete arg1;
78688     } catch (std::out_of_range& e) {
78689       {
78690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78691       };
78692     } catch (std::exception& e) {
78693       {
78694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78695       };
78696     } catch (Dali::DaliException e) {
78697       {
78698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78699       };
78700     } catch (...) {
78701       {
78702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78703       };
78704     }
78705   }
78706
78707 }
78708
78709
78710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
78711   void * jresult ;
78712   Dali::Toolkit::ScrollView *result = 0 ;
78713
78714   {
78715     try {
78716       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
78717     } catch (std::out_of_range& e) {
78718       {
78719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78720       };
78721     } catch (std::exception& e) {
78722       {
78723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78724       };
78725     } catch (Dali::DaliException e) {
78726       {
78727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78728       };
78729     } catch (...) {
78730       {
78731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78732       };
78733     }
78734   }
78735
78736   jresult = (void *)result;
78737   return jresult;
78738 }
78739
78740
78741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
78742   void * jresult ;
78743   Dali::Toolkit::ScrollView *arg1 = 0 ;
78744   Dali::Toolkit::ScrollView *result = 0 ;
78745
78746   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78747   if (!arg1) {
78748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78749     return 0;
78750   }
78751   {
78752     try {
78753       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
78754     } catch (std::out_of_range& e) {
78755       {
78756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78757       };
78758     } catch (std::exception& e) {
78759       {
78760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78761       };
78762     } catch (Dali::DaliException e) {
78763       {
78764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78765       };
78766     } catch (...) {
78767       {
78768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78769       };
78770     }
78771   }
78772
78773   jresult = (void *)result;
78774   return jresult;
78775 }
78776
78777
78778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
78779   void * jresult ;
78780   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78781   Dali::Toolkit::ScrollView *arg2 = 0 ;
78782   Dali::Toolkit::ScrollView *result = 0 ;
78783
78784   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78785   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
78786   if (!arg2) {
78787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
78788     return 0;
78789   }
78790   {
78791     try {
78792       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
78793     } catch (std::out_of_range& e) {
78794       {
78795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78796       };
78797     } catch (std::exception& e) {
78798       {
78799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78800       };
78801     } catch (Dali::DaliException e) {
78802       {
78803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78804       };
78805     } catch (...) {
78806       {
78807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78808       };
78809     }
78810   }
78811
78812   jresult = (void *)result;
78813   return jresult;
78814 }
78815
78816
78817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
78818   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78819
78820   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78821   {
78822     try {
78823       delete arg1;
78824     } catch (std::out_of_range& e) {
78825       {
78826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78827       };
78828     } catch (std::exception& e) {
78829       {
78830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78831       };
78832     } catch (Dali::DaliException e) {
78833       {
78834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78835       };
78836     } catch (...) {
78837       {
78838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78839       };
78840     }
78841   }
78842
78843 }
78844
78845
78846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
78847   void * jresult ;
78848   Dali::Toolkit::ScrollView result;
78849
78850   {
78851     try {
78852       result = Dali::Toolkit::ScrollView::New();
78853     } catch (std::out_of_range& e) {
78854       {
78855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78856       };
78857     } catch (std::exception& e) {
78858       {
78859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78860       };
78861     } catch (Dali::DaliException e) {
78862       {
78863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78864       };
78865     } catch (...) {
78866       {
78867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78868       };
78869     }
78870   }
78871
78872   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78873   return jresult;
78874 }
78875
78876
78877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
78878   void * jresult ;
78879   Dali::BaseHandle arg1 ;
78880   Dali::BaseHandle *argp1 ;
78881   Dali::Toolkit::ScrollView result;
78882
78883   argp1 = (Dali::BaseHandle *)jarg1;
78884   if (!argp1) {
78885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78886     return 0;
78887   }
78888   arg1 = *argp1;
78889   {
78890     try {
78891       result = Dali::Toolkit::ScrollView::DownCast(arg1);
78892     } catch (std::out_of_range& e) {
78893       {
78894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78895       };
78896     } catch (std::exception& e) {
78897       {
78898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78899       };
78900     } catch (Dali::DaliException e) {
78901       {
78902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78903       };
78904     } catch (...) {
78905       {
78906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78907       };
78908     }
78909   }
78910
78911   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
78912   return jresult;
78913 }
78914
78915
78916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
78917   void * jresult ;
78918   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78919   Dali::AlphaFunction result;
78920
78921   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78922   {
78923     try {
78924       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
78925     } catch (std::out_of_range& e) {
78926       {
78927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78928       };
78929     } catch (std::exception& e) {
78930       {
78931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78932       };
78933     } catch (Dali::DaliException e) {
78934       {
78935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78936       };
78937     } catch (...) {
78938       {
78939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78940       };
78941     }
78942   }
78943
78944   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
78945   return jresult;
78946 }
78947
78948
78949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
78950   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78951   Dali::AlphaFunction arg2 ;
78952   Dali::AlphaFunction *argp2 ;
78953
78954   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78955   argp2 = (Dali::AlphaFunction *)jarg2;
78956   if (!argp2) {
78957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
78958     return ;
78959   }
78960   arg2 = *argp2;
78961   {
78962     try {
78963       (arg1)->SetScrollSnapAlphaFunction(arg2);
78964     } catch (std::out_of_range& e) {
78965       {
78966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78967       };
78968     } catch (std::exception& e) {
78969       {
78970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78971       };
78972     } catch (Dali::DaliException e) {
78973       {
78974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78975       };
78976     } catch (...) {
78977       {
78978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78979       };
78980     }
78981   }
78982
78983 }
78984
78985
78986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
78987   void * jresult ;
78988   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78989   Dali::AlphaFunction result;
78990
78991   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78992   {
78993     try {
78994       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
78995     } catch (std::out_of_range& e) {
78996       {
78997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78998       };
78999     } catch (std::exception& e) {
79000       {
79001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79002       };
79003     } catch (Dali::DaliException e) {
79004       {
79005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79006       };
79007     } catch (...) {
79008       {
79009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79010       };
79011     }
79012   }
79013
79014   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79015   return jresult;
79016 }
79017
79018
79019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79020   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79021   Dali::AlphaFunction arg2 ;
79022   Dali::AlphaFunction *argp2 ;
79023
79024   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79025   argp2 = (Dali::AlphaFunction *)jarg2;
79026   if (!argp2) {
79027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79028     return ;
79029   }
79030   arg2 = *argp2;
79031   {
79032     try {
79033       (arg1)->SetScrollFlickAlphaFunction(arg2);
79034     } catch (std::out_of_range& e) {
79035       {
79036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79037       };
79038     } catch (std::exception& e) {
79039       {
79040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79041       };
79042     } catch (Dali::DaliException e) {
79043       {
79044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79045       };
79046     } catch (...) {
79047       {
79048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79049       };
79050     }
79051   }
79052
79053 }
79054
79055
79056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79057   float jresult ;
79058   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79059   float result;
79060
79061   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79062   {
79063     try {
79064       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
79065     } catch (std::out_of_range& e) {
79066       {
79067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79068       };
79069     } catch (std::exception& e) {
79070       {
79071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79072       };
79073     } catch (Dali::DaliException e) {
79074       {
79075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79076       };
79077     } catch (...) {
79078       {
79079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79080       };
79081     }
79082   }
79083
79084   jresult = result;
79085   return jresult;
79086 }
79087
79088
79089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
79090   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79091   float arg2 ;
79092
79093   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79094   arg2 = (float)jarg2;
79095   {
79096     try {
79097       (arg1)->SetScrollSnapDuration(arg2);
79098     } catch (std::out_of_range& e) {
79099       {
79100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79101       };
79102     } catch (std::exception& e) {
79103       {
79104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79105       };
79106     } catch (Dali::DaliException e) {
79107       {
79108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79109       };
79110     } catch (...) {
79111       {
79112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79113       };
79114     }
79115   }
79116
79117 }
79118
79119
79120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
79121   float jresult ;
79122   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79123   float result;
79124
79125   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79126   {
79127     try {
79128       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
79129     } catch (std::out_of_range& e) {
79130       {
79131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79132       };
79133     } catch (std::exception& e) {
79134       {
79135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79136       };
79137     } catch (Dali::DaliException e) {
79138       {
79139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79140       };
79141     } catch (...) {
79142       {
79143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79144       };
79145     }
79146   }
79147
79148   jresult = result;
79149   return jresult;
79150 }
79151
79152
79153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
79154   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79155   float arg2 ;
79156
79157   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79158   arg2 = (float)jarg2;
79159   {
79160     try {
79161       (arg1)->SetScrollFlickDuration(arg2);
79162     } catch (std::out_of_range& e) {
79163       {
79164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79165       };
79166     } catch (std::exception& e) {
79167       {
79168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79169       };
79170     } catch (Dali::DaliException e) {
79171       {
79172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79173       };
79174     } catch (...) {
79175       {
79176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79177       };
79178     }
79179   }
79180
79181 }
79182
79183
79184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
79185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79186   Dali::Toolkit::RulerPtr arg2 ;
79187   Dali::Toolkit::RulerPtr *argp2 ;
79188
79189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79190   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79191   if (!argp2) {
79192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79193     return ;
79194   }
79195   arg2 = *argp2;
79196   {
79197     try {
79198       (arg1)->SetRulerX(arg2);
79199     } catch (std::out_of_range& e) {
79200       {
79201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79202       };
79203     } catch (std::exception& e) {
79204       {
79205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79206       };
79207     } catch (Dali::DaliException e) {
79208       {
79209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79210       };
79211     } catch (...) {
79212       {
79213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79214       };
79215     }
79216   }
79217
79218 }
79219
79220
79221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
79222   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79223   Dali::Toolkit::RulerPtr arg2 ;
79224   Dali::Toolkit::RulerPtr *argp2 ;
79225
79226   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79227   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
79228   if (!argp2) {
79229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
79230     return ;
79231   }
79232   arg2 = *argp2;
79233   {
79234     try {
79235       (arg1)->SetRulerY(arg2);
79236     } catch (std::out_of_range& e) {
79237       {
79238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79239       };
79240     } catch (std::exception& e) {
79241       {
79242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79243       };
79244     } catch (Dali::DaliException e) {
79245       {
79246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79247       };
79248     } catch (...) {
79249       {
79250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79251       };
79252     }
79253   }
79254
79255 }
79256
79257
79258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
79259   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79260   bool arg2 ;
79261
79262   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79263   arg2 = jarg2 ? true : false;
79264   {
79265     try {
79266       (arg1)->SetScrollSensitive(arg2);
79267     } catch (std::out_of_range& e) {
79268       {
79269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79270       };
79271     } catch (std::exception& e) {
79272       {
79273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79274       };
79275     } catch (Dali::DaliException e) {
79276       {
79277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79278       };
79279     } catch (...) {
79280       {
79281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79282       };
79283     }
79284   }
79285
79286 }
79287
79288
79289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
79290   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79291   float arg2 ;
79292   float arg3 ;
79293
79294   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79295   arg2 = (float)jarg2;
79296   arg3 = (float)jarg3;
79297   {
79298     try {
79299       (arg1)->SetMaxOvershoot(arg2,arg3);
79300     } catch (std::out_of_range& e) {
79301       {
79302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79303       };
79304     } catch (std::exception& e) {
79305       {
79306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79307       };
79308     } catch (Dali::DaliException e) {
79309       {
79310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79311       };
79312     } catch (...) {
79313       {
79314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79315       };
79316     }
79317   }
79318
79319 }
79320
79321
79322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
79323   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79324   Dali::AlphaFunction arg2 ;
79325   Dali::AlphaFunction *argp2 ;
79326
79327   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79328   argp2 = (Dali::AlphaFunction *)jarg2;
79329   if (!argp2) {
79330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79331     return ;
79332   }
79333   arg2 = *argp2;
79334   {
79335     try {
79336       (arg1)->SetSnapOvershootAlphaFunction(arg2);
79337     } catch (std::out_of_range& e) {
79338       {
79339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79340       };
79341     } catch (std::exception& e) {
79342       {
79343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79344       };
79345     } catch (Dali::DaliException e) {
79346       {
79347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79348       };
79349     } catch (...) {
79350       {
79351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79352       };
79353     }
79354   }
79355
79356 }
79357
79358
79359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
79360   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79361   float arg2 ;
79362
79363   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79364   arg2 = (float)jarg2;
79365   {
79366     try {
79367       (arg1)->SetSnapOvershootDuration(arg2);
79368     } catch (std::out_of_range& e) {
79369       {
79370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79371       };
79372     } catch (std::exception& e) {
79373       {
79374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79375       };
79376     } catch (Dali::DaliException e) {
79377       {
79378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79379       };
79380     } catch (...) {
79381       {
79382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79383       };
79384     }
79385   }
79386
79387 }
79388
79389
79390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
79391   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79392   bool arg2 ;
79393
79394   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79395   arg2 = jarg2 ? true : false;
79396   {
79397     try {
79398       (arg1)->SetActorAutoSnap(arg2);
79399     } catch (std::out_of_range& e) {
79400       {
79401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79402       };
79403     } catch (std::exception& e) {
79404       {
79405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79406       };
79407     } catch (Dali::DaliException e) {
79408       {
79409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79410       };
79411     } catch (...) {
79412       {
79413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79414       };
79415     }
79416   }
79417
79418 }
79419
79420
79421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
79422   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79423   bool arg2 ;
79424
79425   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79426   arg2 = jarg2 ? true : false;
79427   {
79428     try {
79429       (arg1)->SetWrapMode(arg2);
79430     } catch (std::out_of_range& e) {
79431       {
79432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79433       };
79434     } catch (std::exception& e) {
79435       {
79436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79437       };
79438     } catch (Dali::DaliException e) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79441       };
79442     } catch (...) {
79443       {
79444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79445       };
79446     }
79447   }
79448
79449 }
79450
79451
79452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
79453   int jresult ;
79454   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79455   int result;
79456
79457   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79458   {
79459     try {
79460       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
79461     } catch (std::out_of_range& e) {
79462       {
79463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79464       };
79465     } catch (std::exception& e) {
79466       {
79467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79468       };
79469     } catch (Dali::DaliException e) {
79470       {
79471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79472       };
79473     } catch (...) {
79474       {
79475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79476       };
79477     }
79478   }
79479
79480   jresult = result;
79481   return jresult;
79482 }
79483
79484
79485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
79486   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79487   int arg2 ;
79488
79489   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79490   arg2 = (int)jarg2;
79491   {
79492     try {
79493       (arg1)->SetScrollUpdateDistance(arg2);
79494     } catch (std::out_of_range& e) {
79495       {
79496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79497       };
79498     } catch (std::exception& e) {
79499       {
79500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79501       };
79502     } catch (Dali::DaliException e) {
79503       {
79504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79505       };
79506     } catch (...) {
79507       {
79508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79509       };
79510     }
79511   }
79512
79513 }
79514
79515
79516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
79517   unsigned int jresult ;
79518   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79519   bool result;
79520
79521   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79522   {
79523     try {
79524       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
79525     } catch (std::out_of_range& e) {
79526       {
79527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79528       };
79529     } catch (std::exception& e) {
79530       {
79531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79532       };
79533     } catch (Dali::DaliException e) {
79534       {
79535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79536       };
79537     } catch (...) {
79538       {
79539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79540       };
79541     }
79542   }
79543
79544   jresult = result;
79545   return jresult;
79546 }
79547
79548
79549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
79550   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79551   bool arg2 ;
79552
79553   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79554   arg2 = jarg2 ? true : false;
79555   {
79556     try {
79557       (arg1)->SetAxisAutoLock(arg2);
79558     } catch (std::out_of_range& e) {
79559       {
79560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79561       };
79562     } catch (std::exception& e) {
79563       {
79564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79565       };
79566     } catch (Dali::DaliException e) {
79567       {
79568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79569       };
79570     } catch (...) {
79571       {
79572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79573       };
79574     }
79575   }
79576
79577 }
79578
79579
79580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
79581   float jresult ;
79582   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79583   float result;
79584
79585   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79586   {
79587     try {
79588       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
79589     } catch (std::out_of_range& e) {
79590       {
79591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79592       };
79593     } catch (std::exception& e) {
79594       {
79595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79596       };
79597     } catch (Dali::DaliException e) {
79598       {
79599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79600       };
79601     } catch (...) {
79602       {
79603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79604       };
79605     }
79606   }
79607
79608   jresult = result;
79609   return jresult;
79610 }
79611
79612
79613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
79614   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79615   float arg2 ;
79616
79617   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79618   arg2 = (float)jarg2;
79619   {
79620     try {
79621       (arg1)->SetAxisAutoLockGradient(arg2);
79622     } catch (std::out_of_range& e) {
79623       {
79624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79625       };
79626     } catch (std::exception& e) {
79627       {
79628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79629       };
79630     } catch (Dali::DaliException e) {
79631       {
79632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79633       };
79634     } catch (...) {
79635       {
79636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79637       };
79638     }
79639   }
79640
79641 }
79642
79643
79644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
79645   float jresult ;
79646   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79647   float result;
79648
79649   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79650   {
79651     try {
79652       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
79653     } catch (std::out_of_range& e) {
79654       {
79655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79656       };
79657     } catch (std::exception& e) {
79658       {
79659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79660       };
79661     } catch (Dali::DaliException e) {
79662       {
79663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79664       };
79665     } catch (...) {
79666       {
79667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79668       };
79669     }
79670   }
79671
79672   jresult = result;
79673   return jresult;
79674 }
79675
79676
79677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
79678   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79679   float arg2 ;
79680
79681   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79682   arg2 = (float)jarg2;
79683   {
79684     try {
79685       (arg1)->SetFrictionCoefficient(arg2);
79686     } catch (std::out_of_range& e) {
79687       {
79688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79689       };
79690     } catch (std::exception& e) {
79691       {
79692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79693       };
79694     } catch (Dali::DaliException e) {
79695       {
79696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79697       };
79698     } catch (...) {
79699       {
79700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79701       };
79702     }
79703   }
79704
79705 }
79706
79707
79708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
79709   float jresult ;
79710   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79711   float result;
79712
79713   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79714   {
79715     try {
79716       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
79717     } catch (std::out_of_range& e) {
79718       {
79719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79720       };
79721     } catch (std::exception& e) {
79722       {
79723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79724       };
79725     } catch (Dali::DaliException e) {
79726       {
79727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79728       };
79729     } catch (...) {
79730       {
79731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79732       };
79733     }
79734   }
79735
79736   jresult = result;
79737   return jresult;
79738 }
79739
79740
79741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
79742   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79743   float arg2 ;
79744
79745   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79746   arg2 = (float)jarg2;
79747   {
79748     try {
79749       (arg1)->SetFlickSpeedCoefficient(arg2);
79750     } catch (std::out_of_range& e) {
79751       {
79752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79753       };
79754     } catch (std::exception& e) {
79755       {
79756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79757       };
79758     } catch (Dali::DaliException e) {
79759       {
79760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79761       };
79762     } catch (...) {
79763       {
79764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79765       };
79766     }
79767   }
79768
79769 }
79770
79771
79772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
79773   void * jresult ;
79774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79775   Dali::Vector2 result;
79776
79777   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79778   {
79779     try {
79780       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
79781     } catch (std::out_of_range& e) {
79782       {
79783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79784       };
79785     } catch (std::exception& e) {
79786       {
79787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79788       };
79789     } catch (Dali::DaliException e) {
79790       {
79791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79792       };
79793     } catch (...) {
79794       {
79795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79796       };
79797     }
79798   }
79799
79800   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79801   return jresult;
79802 }
79803
79804
79805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
79806   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79807   Dali::Vector2 *arg2 = 0 ;
79808
79809   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79810   arg2 = (Dali::Vector2 *)jarg2;
79811   if (!arg2) {
79812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79813     return ;
79814   }
79815   {
79816     try {
79817       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
79818     } catch (std::out_of_range& e) {
79819       {
79820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79821       };
79822     } catch (std::exception& e) {
79823       {
79824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79825       };
79826     } catch (Dali::DaliException e) {
79827       {
79828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79829       };
79830     } catch (...) {
79831       {
79832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79833       };
79834     }
79835   }
79836
79837 }
79838
79839
79840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
79841   float jresult ;
79842   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79843   float result;
79844
79845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79846   {
79847     try {
79848       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
79849     } catch (std::out_of_range& e) {
79850       {
79851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79852       };
79853     } catch (std::exception& e) {
79854       {
79855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79856       };
79857     } catch (Dali::DaliException e) {
79858       {
79859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79860       };
79861     } catch (...) {
79862       {
79863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79864       };
79865     }
79866   }
79867
79868   jresult = result;
79869   return jresult;
79870 }
79871
79872
79873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
79874   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79875   float arg2 ;
79876
79877   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79878   arg2 = (float)jarg2;
79879   {
79880     try {
79881       (arg1)->SetMinimumSpeedForFlick(arg2);
79882     } catch (std::out_of_range& e) {
79883       {
79884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79885       };
79886     } catch (std::exception& e) {
79887       {
79888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79889       };
79890     } catch (Dali::DaliException e) {
79891       {
79892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79893       };
79894     } catch (...) {
79895       {
79896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79897       };
79898     }
79899   }
79900
79901 }
79902
79903
79904 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
79905   float jresult ;
79906   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79907   float result;
79908
79909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79910   {
79911     try {
79912       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
79913     } catch (std::out_of_range& e) {
79914       {
79915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79916       };
79917     } catch (std::exception& e) {
79918       {
79919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79920       };
79921     } catch (Dali::DaliException e) {
79922       {
79923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79924       };
79925     } catch (...) {
79926       {
79927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79928       };
79929     }
79930   }
79931
79932   jresult = result;
79933   return jresult;
79934 }
79935
79936
79937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
79938   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79939   float arg2 ;
79940
79941   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79942   arg2 = (float)jarg2;
79943   {
79944     try {
79945       (arg1)->SetMaxFlickSpeed(arg2);
79946     } catch (std::out_of_range& e) {
79947       {
79948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79949       };
79950     } catch (std::exception& e) {
79951       {
79952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79953       };
79954     } catch (Dali::DaliException e) {
79955       {
79956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79957       };
79958     } catch (...) {
79959       {
79960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79961       };
79962     }
79963   }
79964
79965 }
79966
79967
79968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
79969   void * jresult ;
79970   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79971   Dali::Vector2 result;
79972
79973   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79974   {
79975     try {
79976       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
79977     } catch (std::out_of_range& e) {
79978       {
79979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79980       };
79981     } catch (std::exception& e) {
79982       {
79983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79984       };
79985     } catch (Dali::DaliException e) {
79986       {
79987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79988       };
79989     } catch (...) {
79990       {
79991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79992       };
79993     }
79994   }
79995
79996   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79997   return jresult;
79998 }
79999
80000
80001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80002   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80003   Dali::Vector2 arg2 ;
80004   Dali::Vector2 *argp2 ;
80005
80006   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80007   argp2 = (Dali::Vector2 *)jarg2;
80008   if (!argp2) {
80009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80010     return ;
80011   }
80012   arg2 = *argp2;
80013   {
80014     try {
80015       (arg1)->SetWheelScrollDistanceStep(arg2);
80016     } catch (std::out_of_range& e) {
80017       {
80018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80019       };
80020     } catch (std::exception& e) {
80021       {
80022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80023       };
80024     } catch (Dali::DaliException e) {
80025       {
80026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80027       };
80028     } catch (...) {
80029       {
80030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80031       };
80032     }
80033   }
80034
80035 }
80036
80037
80038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80039   void * jresult ;
80040   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80041   Dali::Vector2 result;
80042
80043   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80044   {
80045     try {
80046       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80047     } catch (std::out_of_range& e) {
80048       {
80049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80050       };
80051     } catch (std::exception& e) {
80052       {
80053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80054       };
80055     } catch (Dali::DaliException e) {
80056       {
80057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80058       };
80059     } catch (...) {
80060       {
80061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80062       };
80063     }
80064   }
80065
80066   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80067   return jresult;
80068 }
80069
80070
80071 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
80072   unsigned int jresult ;
80073   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80074   unsigned int result;
80075
80076   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80077   {
80078     try {
80079       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
80080     } catch (std::out_of_range& e) {
80081       {
80082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80083       };
80084     } catch (std::exception& e) {
80085       {
80086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80087       };
80088     } catch (Dali::DaliException e) {
80089       {
80090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80091       };
80092     } catch (...) {
80093       {
80094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80095       };
80096     }
80097   }
80098
80099   jresult = result;
80100   return jresult;
80101 }
80102
80103
80104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
80105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80106   Dali::Vector2 *arg2 = 0 ;
80107
80108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80109   arg2 = (Dali::Vector2 *)jarg2;
80110   if (!arg2) {
80111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80112     return ;
80113   }
80114   {
80115     try {
80116       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
80117     } catch (std::out_of_range& e) {
80118       {
80119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80120       };
80121     } catch (std::exception& e) {
80122       {
80123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80124       };
80125     } catch (Dali::DaliException e) {
80126       {
80127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80128       };
80129     } catch (...) {
80130       {
80131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80132       };
80133     }
80134   }
80135
80136 }
80137
80138
80139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
80140   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80141   Dali::Vector2 *arg2 = 0 ;
80142   float arg3 ;
80143
80144   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80145   arg2 = (Dali::Vector2 *)jarg2;
80146   if (!arg2) {
80147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80148     return ;
80149   }
80150   arg3 = (float)jarg3;
80151   {
80152     try {
80153       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
80154     } catch (std::out_of_range& e) {
80155       {
80156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80157       };
80158     } catch (std::exception& e) {
80159       {
80160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80161       };
80162     } catch (Dali::DaliException e) {
80163       {
80164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80165       };
80166     } catch (...) {
80167       {
80168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80169       };
80170     }
80171   }
80172
80173 }
80174
80175
80176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
80177   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80178   Dali::Vector2 *arg2 = 0 ;
80179   float arg3 ;
80180   Dali::AlphaFunction arg4 ;
80181   Dali::AlphaFunction *argp4 ;
80182
80183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80184   arg2 = (Dali::Vector2 *)jarg2;
80185   if (!arg2) {
80186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80187     return ;
80188   }
80189   arg3 = (float)jarg3;
80190   argp4 = (Dali::AlphaFunction *)jarg4;
80191   if (!argp4) {
80192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80193     return ;
80194   }
80195   arg4 = *argp4;
80196   {
80197     try {
80198       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
80199     } catch (std::out_of_range& e) {
80200       {
80201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80202       };
80203     } catch (std::exception& e) {
80204       {
80205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80206       };
80207     } catch (Dali::DaliException e) {
80208       {
80209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80210       };
80211     } catch (...) {
80212       {
80213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80214       };
80215     }
80216   }
80217
80218 }
80219
80220
80221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
80222   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80223   Dali::Vector2 *arg2 = 0 ;
80224   float arg3 ;
80225   Dali::Toolkit::DirectionBias arg4 ;
80226   Dali::Toolkit::DirectionBias arg5 ;
80227
80228   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80229   arg2 = (Dali::Vector2 *)jarg2;
80230   if (!arg2) {
80231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80232     return ;
80233   }
80234   arg3 = (float)jarg3;
80235   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80236   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80237   {
80238     try {
80239       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
80240     } catch (std::out_of_range& e) {
80241       {
80242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80243       };
80244     } catch (std::exception& e) {
80245       {
80246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80247       };
80248     } catch (Dali::DaliException e) {
80249       {
80250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80251       };
80252     } catch (...) {
80253       {
80254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80255       };
80256     }
80257   }
80258
80259 }
80260
80261
80262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
80263   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80264   Dali::Vector2 *arg2 = 0 ;
80265   float arg3 ;
80266   Dali::AlphaFunction arg4 ;
80267   Dali::Toolkit::DirectionBias arg5 ;
80268   Dali::Toolkit::DirectionBias arg6 ;
80269   Dali::AlphaFunction *argp4 ;
80270
80271   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80272   arg2 = (Dali::Vector2 *)jarg2;
80273   if (!arg2) {
80274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80275     return ;
80276   }
80277   arg3 = (float)jarg3;
80278   argp4 = (Dali::AlphaFunction *)jarg4;
80279   if (!argp4) {
80280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80281     return ;
80282   }
80283   arg4 = *argp4;
80284   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
80285   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
80286   {
80287     try {
80288       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
80289     } catch (std::out_of_range& e) {
80290       {
80291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80292       };
80293     } catch (std::exception& e) {
80294       {
80295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80296       };
80297     } catch (Dali::DaliException e) {
80298       {
80299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80300       };
80301     } catch (...) {
80302       {
80303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80304       };
80305     }
80306   }
80307
80308 }
80309
80310
80311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
80312   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80313   unsigned int arg2 ;
80314
80315   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80316   arg2 = (unsigned int)jarg2;
80317   {
80318     try {
80319       (arg1)->ScrollTo(arg2);
80320     } catch (std::out_of_range& e) {
80321       {
80322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80323       };
80324     } catch (std::exception& e) {
80325       {
80326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80327       };
80328     } catch (Dali::DaliException e) {
80329       {
80330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80331       };
80332     } catch (...) {
80333       {
80334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80335       };
80336     }
80337   }
80338
80339 }
80340
80341
80342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
80343   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80344   unsigned int arg2 ;
80345   float arg3 ;
80346
80347   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80348   arg2 = (unsigned int)jarg2;
80349   arg3 = (float)jarg3;
80350   {
80351     try {
80352       (arg1)->ScrollTo(arg2,arg3);
80353     } catch (std::out_of_range& e) {
80354       {
80355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80356       };
80357     } catch (std::exception& e) {
80358       {
80359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80360       };
80361     } catch (Dali::DaliException e) {
80362       {
80363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80364       };
80365     } catch (...) {
80366       {
80367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80368       };
80369     }
80370   }
80371
80372 }
80373
80374
80375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
80376   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80377   unsigned int arg2 ;
80378   float arg3 ;
80379   Dali::Toolkit::DirectionBias arg4 ;
80380
80381   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80382   arg2 = (unsigned int)jarg2;
80383   arg3 = (float)jarg3;
80384   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
80385   {
80386     try {
80387       (arg1)->ScrollTo(arg2,arg3,arg4);
80388     } catch (std::out_of_range& e) {
80389       {
80390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80391       };
80392     } catch (std::exception& e) {
80393       {
80394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80395       };
80396     } catch (Dali::DaliException e) {
80397       {
80398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80399       };
80400     } catch (...) {
80401       {
80402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80403       };
80404     }
80405   }
80406
80407 }
80408
80409
80410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
80411   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80412   Dali::Actor *arg2 = 0 ;
80413
80414   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80415   arg2 = (Dali::Actor *)jarg2;
80416   if (!arg2) {
80417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80418     return ;
80419   }
80420   {
80421     try {
80422       (arg1)->ScrollTo(*arg2);
80423     } catch (std::out_of_range& e) {
80424       {
80425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80426       };
80427     } catch (std::exception& e) {
80428       {
80429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80430       };
80431     } catch (Dali::DaliException e) {
80432       {
80433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80434       };
80435     } catch (...) {
80436       {
80437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80438       };
80439     }
80440   }
80441
80442 }
80443
80444
80445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
80446   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80447   Dali::Actor *arg2 = 0 ;
80448   float arg3 ;
80449
80450   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80451   arg2 = (Dali::Actor *)jarg2;
80452   if (!arg2) {
80453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
80454     return ;
80455   }
80456   arg3 = (float)jarg3;
80457   {
80458     try {
80459       (arg1)->ScrollTo(*arg2,arg3);
80460     } catch (std::out_of_range& e) {
80461       {
80462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80463       };
80464     } catch (std::exception& e) {
80465       {
80466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80467       };
80468     } catch (Dali::DaliException e) {
80469       {
80470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80471       };
80472     } catch (...) {
80473       {
80474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80475       };
80476     }
80477   }
80478
80479 }
80480
80481
80482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
80483   unsigned int jresult ;
80484   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80485   bool result;
80486
80487   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80488   {
80489     try {
80490       result = (bool)(arg1)->ScrollToSnapPoint();
80491     } catch (std::out_of_range& e) {
80492       {
80493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80494       };
80495     } catch (std::exception& e) {
80496       {
80497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80498       };
80499     } catch (Dali::DaliException e) {
80500       {
80501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80502       };
80503     } catch (...) {
80504       {
80505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80506       };
80507     }
80508   }
80509
80510   jresult = result;
80511   return jresult;
80512 }
80513
80514
80515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
80516   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80517   Dali::Constraint arg2 ;
80518   Dali::Constraint *argp2 ;
80519
80520   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80521   argp2 = (Dali::Constraint *)jarg2;
80522   if (!argp2) {
80523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
80524     return ;
80525   }
80526   arg2 = *argp2;
80527   {
80528     try {
80529       (arg1)->ApplyConstraintToChildren(arg2);
80530     } catch (std::out_of_range& e) {
80531       {
80532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80533       };
80534     } catch (std::exception& e) {
80535       {
80536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80537       };
80538     } catch (Dali::DaliException e) {
80539       {
80540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80541       };
80542     } catch (...) {
80543       {
80544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80545       };
80546     }
80547   }
80548
80549 }
80550
80551
80552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
80553   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80554
80555   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80556   {
80557     try {
80558       (arg1)->RemoveConstraintsFromChildren();
80559     } catch (std::out_of_range& e) {
80560       {
80561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80562       };
80563     } catch (std::exception& e) {
80564       {
80565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80566       };
80567     } catch (Dali::DaliException e) {
80568       {
80569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80570       };
80571     } catch (...) {
80572       {
80573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80574       };
80575     }
80576   }
80577
80578 }
80579
80580
80581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
80582   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80583   Dali::Toolkit::ScrollViewEffect arg2 ;
80584   Dali::Toolkit::ScrollViewEffect *argp2 ;
80585
80586   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80587   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80588   if (!argp2) {
80589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80590     return ;
80591   }
80592   arg2 = *argp2;
80593   {
80594     try {
80595       (arg1)->ApplyEffect(arg2);
80596     } catch (std::out_of_range& e) {
80597       {
80598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80599       };
80600     } catch (std::exception& e) {
80601       {
80602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80603       };
80604     } catch (Dali::DaliException e) {
80605       {
80606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80607       };
80608     } catch (...) {
80609       {
80610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80611       };
80612     }
80613   }
80614
80615 }
80616
80617
80618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
80619   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80620   Dali::Toolkit::ScrollViewEffect arg2 ;
80621   Dali::Toolkit::ScrollViewEffect *argp2 ;
80622
80623   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80624   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
80625   if (!argp2) {
80626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
80627     return ;
80628   }
80629   arg2 = *argp2;
80630   {
80631     try {
80632       (arg1)->RemoveEffect(arg2);
80633     } catch (std::out_of_range& e) {
80634       {
80635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80636       };
80637     } catch (std::exception& e) {
80638       {
80639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80640       };
80641     } catch (Dali::DaliException e) {
80642       {
80643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80644       };
80645     } catch (...) {
80646       {
80647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80648       };
80649     }
80650   }
80651
80652 }
80653
80654
80655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
80656   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80657
80658   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80659   {
80660     try {
80661       (arg1)->RemoveAllEffects();
80662     } catch (std::out_of_range& e) {
80663       {
80664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80665       };
80666     } catch (std::exception& e) {
80667       {
80668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80669       };
80670     } catch (Dali::DaliException e) {
80671       {
80672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80673       };
80674     } catch (...) {
80675       {
80676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80677       };
80678     }
80679   }
80680
80681 }
80682
80683
80684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
80685   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80686   Dali::Actor arg2 ;
80687   Dali::Actor *argp2 ;
80688
80689   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80690   argp2 = (Dali::Actor *)jarg2;
80691   if (!argp2) {
80692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80693     return ;
80694   }
80695   arg2 = *argp2;
80696   {
80697     try {
80698       (arg1)->BindActor(arg2);
80699     } catch (std::out_of_range& e) {
80700       {
80701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80702       };
80703     } catch (std::exception& e) {
80704       {
80705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80706       };
80707     } catch (Dali::DaliException e) {
80708       {
80709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80710       };
80711     } catch (...) {
80712       {
80713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80714       };
80715     }
80716   }
80717
80718 }
80719
80720
80721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
80722   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80723   Dali::Actor arg2 ;
80724   Dali::Actor *argp2 ;
80725
80726   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80727   argp2 = (Dali::Actor *)jarg2;
80728   if (!argp2) {
80729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80730     return ;
80731   }
80732   arg2 = *argp2;
80733   {
80734     try {
80735       (arg1)->UnbindActor(arg2);
80736     } catch (std::out_of_range& e) {
80737       {
80738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80739       };
80740     } catch (std::exception& e) {
80741       {
80742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80743       };
80744     } catch (Dali::DaliException e) {
80745       {
80746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80747       };
80748     } catch (...) {
80749       {
80750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80751       };
80752     }
80753   }
80754
80755 }
80756
80757
80758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
80759   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80760   Dali::Radian arg2 ;
80761   Dali::Radian arg3 ;
80762   Dali::Radian *argp2 ;
80763   Dali::Radian *argp3 ;
80764
80765   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80766   argp2 = (Dali::Radian *)jarg2;
80767   if (!argp2) {
80768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80769     return ;
80770   }
80771   arg2 = *argp2;
80772   argp3 = (Dali::Radian *)jarg3;
80773   if (!argp3) {
80774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80775     return ;
80776   }
80777   arg3 = *argp3;
80778   {
80779     try {
80780       (arg1)->SetScrollingDirection(arg2,arg3);
80781     } catch (std::out_of_range& e) {
80782       {
80783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80784       };
80785     } catch (std::exception& e) {
80786       {
80787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80788       };
80789     } catch (Dali::DaliException e) {
80790       {
80791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80792       };
80793     } catch (...) {
80794       {
80795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80796       };
80797     }
80798   }
80799
80800 }
80801
80802
80803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
80804   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80805   Dali::Radian arg2 ;
80806   Dali::Radian *argp2 ;
80807
80808   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80809   argp2 = (Dali::Radian *)jarg2;
80810   if (!argp2) {
80811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80812     return ;
80813   }
80814   arg2 = *argp2;
80815   {
80816     try {
80817       (arg1)->SetScrollingDirection(arg2);
80818     } catch (std::out_of_range& e) {
80819       {
80820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80821       };
80822     } catch (std::exception& e) {
80823       {
80824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80825       };
80826     } catch (Dali::DaliException e) {
80827       {
80828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80829       };
80830     } catch (...) {
80831       {
80832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80833       };
80834     }
80835   }
80836
80837 }
80838
80839
80840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
80841   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80842   Dali::Radian arg2 ;
80843   Dali::Radian *argp2 ;
80844
80845   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80846   argp2 = (Dali::Radian *)jarg2;
80847   if (!argp2) {
80848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
80849     return ;
80850   }
80851   arg2 = *argp2;
80852   {
80853     try {
80854       (arg1)->RemoveScrollingDirection(arg2);
80855     } catch (std::out_of_range& e) {
80856       {
80857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80858       };
80859     } catch (std::exception& e) {
80860       {
80861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80862       };
80863     } catch (Dali::DaliException e) {
80864       {
80865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80866       };
80867     } catch (...) {
80868       {
80869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80870       };
80871     }
80872   }
80873
80874 }
80875
80876
80877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
80878   void * jresult ;
80879   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80880   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
80881
80882   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80883   {
80884     try {
80885       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
80886     } catch (std::out_of_range& e) {
80887       {
80888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80889       };
80890     } catch (std::exception& e) {
80891       {
80892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80893       };
80894     } catch (Dali::DaliException e) {
80895       {
80896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80897       };
80898     } catch (...) {
80899       {
80900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80901       };
80902     }
80903   }
80904
80905   jresult = (void *)result;
80906   return jresult;
80907 }
80908
80909
80910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
80911   int jresult ;
80912   int result;
80913
80914   result = (int)Dali::Toolkit::TableView::Property::ROWS;
80915   jresult = (int)result;
80916   return jresult;
80917 }
80918
80919
80920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
80921   int jresult ;
80922   int result;
80923
80924   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
80925   jresult = (int)result;
80926   return jresult;
80927 }
80928
80929
80930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
80931   int jresult ;
80932   int result;
80933
80934   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
80935   jresult = (int)result;
80936   return jresult;
80937 }
80938
80939
80940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
80941   int jresult ;
80942   int result;
80943
80944   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
80945   jresult = (int)result;
80946   return jresult;
80947 }
80948
80949
80950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
80951   int jresult ;
80952   int result;
80953
80954   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
80955   jresult = (int)result;
80956   return jresult;
80957 }
80958
80959
80960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
80961   void * jresult ;
80962   Dali::Toolkit::TableView::Property *result = 0 ;
80963
80964   {
80965     try {
80966       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
80967     } catch (std::out_of_range& e) {
80968       {
80969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80970       };
80971     } catch (std::exception& e) {
80972       {
80973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80974       };
80975     } catch (Dali::DaliException e) {
80976       {
80977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80978       };
80979     } catch (...) {
80980       {
80981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80982       };
80983     }
80984   }
80985
80986   jresult = (void *)result;
80987   return jresult;
80988 }
80989
80990
80991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
80992   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
80993
80994   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
80995   {
80996     try {
80997       delete arg1;
80998     } catch (std::out_of_range& e) {
80999       {
81000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81001       };
81002     } catch (std::exception& e) {
81003       {
81004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81005       };
81006     } catch (Dali::DaliException e) {
81007       {
81008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81009       };
81010     } catch (...) {
81011       {
81012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81013       };
81014     }
81015   }
81016
81017 }
81018
81019
81020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81021   int jresult ;
81022   int result;
81023
81024   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81025   jresult = (int)result;
81026   return jresult;
81027 }
81028
81029
81030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81031   int jresult ;
81032   int result;
81033
81034   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81035   jresult = (int)result;
81036   return jresult;
81037 }
81038
81039
81040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81041   int jresult ;
81042   int result;
81043
81044   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81045   jresult = (int)result;
81046   return jresult;
81047 }
81048
81049
81050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81051   int jresult ;
81052   int result;
81053
81054   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81055   jresult = (int)result;
81056   return jresult;
81057 }
81058
81059
81060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81061   int jresult ;
81062   int result;
81063
81064   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81065   jresult = (int)result;
81066   return jresult;
81067 }
81068
81069
81070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
81071   void * jresult ;
81072   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
81073
81074   {
81075     try {
81076       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
81077     } catch (std::out_of_range& e) {
81078       {
81079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81080       };
81081     } catch (std::exception& e) {
81082       {
81083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81084       };
81085     } catch (Dali::DaliException e) {
81086       {
81087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81088       };
81089     } catch (...) {
81090       {
81091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81092       };
81093     }
81094   }
81095
81096   jresult = (void *)result;
81097   return jresult;
81098 }
81099
81100
81101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
81102   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
81103
81104   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
81105   {
81106     try {
81107       delete arg1;
81108     } catch (std::out_of_range& e) {
81109       {
81110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81111       };
81112     } catch (std::exception& e) {
81113       {
81114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81115       };
81116     } catch (Dali::DaliException e) {
81117       {
81118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81119       };
81120     } catch (...) {
81121       {
81122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81123       };
81124     }
81125   }
81126
81127 }
81128
81129
81130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
81131   void * jresult ;
81132   unsigned int arg1 ;
81133   unsigned int arg2 ;
81134   unsigned int arg3 ;
81135   unsigned int arg4 ;
81136   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81137
81138   arg1 = (unsigned int)jarg1;
81139   arg2 = (unsigned int)jarg2;
81140   arg3 = (unsigned int)jarg3;
81141   arg4 = (unsigned int)jarg4;
81142   {
81143     try {
81144       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
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_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
81170   void * jresult ;
81171   unsigned int arg1 ;
81172   unsigned int arg2 ;
81173   unsigned int arg3 ;
81174   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81175
81176   arg1 = (unsigned int)jarg1;
81177   arg2 = (unsigned int)jarg2;
81178   arg3 = (unsigned int)jarg3;
81179   {
81180     try {
81181       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
81182     } catch (std::out_of_range& e) {
81183       {
81184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81185       };
81186     } catch (std::exception& e) {
81187       {
81188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81189       };
81190     } catch (Dali::DaliException e) {
81191       {
81192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81193       };
81194     } catch (...) {
81195       {
81196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81197       };
81198     }
81199   }
81200
81201   jresult = (void *)result;
81202   return jresult;
81203 }
81204
81205
81206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
81207   void * jresult ;
81208   unsigned int arg1 ;
81209   unsigned int arg2 ;
81210   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81211
81212   arg1 = (unsigned int)jarg1;
81213   arg2 = (unsigned int)jarg2;
81214   {
81215     try {
81216       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
81217     } catch (std::out_of_range& e) {
81218       {
81219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81220       };
81221     } catch (std::exception& e) {
81222       {
81223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81224       };
81225     } catch (Dali::DaliException e) {
81226       {
81227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81228       };
81229     } catch (...) {
81230       {
81231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81232       };
81233     }
81234   }
81235
81236   jresult = (void *)result;
81237   return jresult;
81238 }
81239
81240
81241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
81242   void * jresult ;
81243   unsigned int arg1 ;
81244   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81245
81246   arg1 = (unsigned int)jarg1;
81247   {
81248     try {
81249       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
81250     } catch (std::out_of_range& e) {
81251       {
81252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81253       };
81254     } catch (std::exception& e) {
81255       {
81256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81257       };
81258     } catch (Dali::DaliException e) {
81259       {
81260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81261       };
81262     } catch (...) {
81263       {
81264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81265       };
81266     }
81267   }
81268
81269   jresult = (void *)result;
81270   return jresult;
81271 }
81272
81273
81274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
81275   void * jresult ;
81276   Dali::Toolkit::TableView::CellPosition *result = 0 ;
81277
81278   {
81279     try {
81280       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
81281     } catch (std::out_of_range& e) {
81282       {
81283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81284       };
81285     } catch (std::exception& e) {
81286       {
81287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81288       };
81289     } catch (Dali::DaliException e) {
81290       {
81291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81292       };
81293     } catch (...) {
81294       {
81295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81296       };
81297     }
81298   }
81299
81300   jresult = (void *)result;
81301   return jresult;
81302 }
81303
81304
81305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
81306   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81307   unsigned int arg2 ;
81308
81309   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81310   arg2 = (unsigned int)jarg2;
81311   if (arg1) (arg1)->rowIndex = arg2;
81312 }
81313
81314
81315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
81316   unsigned int jresult ;
81317   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81318   unsigned int result;
81319
81320   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81321   result = (unsigned int) ((arg1)->rowIndex);
81322   jresult = result;
81323   return jresult;
81324 }
81325
81326
81327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
81328   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81329   unsigned int arg2 ;
81330
81331   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81332   arg2 = (unsigned int)jarg2;
81333   if (arg1) (arg1)->columnIndex = arg2;
81334 }
81335
81336
81337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
81338   unsigned int jresult ;
81339   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81340   unsigned int result;
81341
81342   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81343   result = (unsigned int) ((arg1)->columnIndex);
81344   jresult = result;
81345   return jresult;
81346 }
81347
81348
81349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
81350   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81351   unsigned int arg2 ;
81352
81353   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81354   arg2 = (unsigned int)jarg2;
81355   if (arg1) (arg1)->rowSpan = arg2;
81356 }
81357
81358
81359 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
81360   unsigned int jresult ;
81361   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81362   unsigned int result;
81363
81364   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81365   result = (unsigned int) ((arg1)->rowSpan);
81366   jresult = result;
81367   return jresult;
81368 }
81369
81370
81371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
81372   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81373   unsigned int arg2 ;
81374
81375   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81376   arg2 = (unsigned int)jarg2;
81377   if (arg1) (arg1)->columnSpan = arg2;
81378 }
81379
81380
81381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
81382   unsigned int jresult ;
81383   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81384   unsigned int result;
81385
81386   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81387   result = (unsigned int) ((arg1)->columnSpan);
81388   jresult = result;
81389   return jresult;
81390 }
81391
81392
81393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
81394   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
81395
81396   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
81397   {
81398     try {
81399       delete arg1;
81400     } catch (std::out_of_range& e) {
81401       {
81402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81403       };
81404     } catch (std::exception& e) {
81405       {
81406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81407       };
81408     } catch (Dali::DaliException e) {
81409       {
81410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81411       };
81412     } catch (...) {
81413       {
81414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81415       };
81416     }
81417   }
81418
81419 }
81420
81421
81422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
81423   void * jresult ;
81424   Dali::Toolkit::TableView *result = 0 ;
81425
81426   {
81427     try {
81428       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
81429     } catch (std::out_of_range& e) {
81430       {
81431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81432       };
81433     } catch (std::exception& e) {
81434       {
81435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81436       };
81437     } catch (Dali::DaliException e) {
81438       {
81439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81440       };
81441     } catch (...) {
81442       {
81443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81444       };
81445     }
81446   }
81447
81448   jresult = (void *)result;
81449   return jresult;
81450 }
81451
81452
81453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
81454   void * jresult ;
81455   Dali::Toolkit::TableView *arg1 = 0 ;
81456   Dali::Toolkit::TableView *result = 0 ;
81457
81458   arg1 = (Dali::Toolkit::TableView *)jarg1;
81459   if (!arg1) {
81460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81461     return 0;
81462   }
81463   {
81464     try {
81465       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
81466     } catch (std::out_of_range& e) {
81467       {
81468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81469       };
81470     } catch (std::exception& e) {
81471       {
81472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81473       };
81474     } catch (Dali::DaliException e) {
81475       {
81476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81477       };
81478     } catch (...) {
81479       {
81480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81481       };
81482     }
81483   }
81484
81485   jresult = (void *)result;
81486   return jresult;
81487 }
81488
81489
81490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
81491   void * jresult ;
81492   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81493   Dali::Toolkit::TableView *arg2 = 0 ;
81494   Dali::Toolkit::TableView *result = 0 ;
81495
81496   arg1 = (Dali::Toolkit::TableView *)jarg1;
81497   arg2 = (Dali::Toolkit::TableView *)jarg2;
81498   if (!arg2) {
81499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
81500     return 0;
81501   }
81502   {
81503     try {
81504       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
81505     } catch (std::out_of_range& e) {
81506       {
81507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81508       };
81509     } catch (std::exception& e) {
81510       {
81511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81512       };
81513     } catch (Dali::DaliException e) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81516       };
81517     } catch (...) {
81518       {
81519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81520       };
81521     }
81522   }
81523
81524   jresult = (void *)result;
81525   return jresult;
81526 }
81527
81528
81529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
81530   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81531
81532   arg1 = (Dali::Toolkit::TableView *)jarg1;
81533   {
81534     try {
81535       delete arg1;
81536     } catch (std::out_of_range& e) {
81537       {
81538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81539       };
81540     } catch (std::exception& e) {
81541       {
81542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81543       };
81544     } catch (Dali::DaliException e) {
81545       {
81546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81547       };
81548     } catch (...) {
81549       {
81550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81551       };
81552     }
81553   }
81554
81555 }
81556
81557
81558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
81559   void * jresult ;
81560   unsigned int arg1 ;
81561   unsigned int arg2 ;
81562   Dali::Toolkit::TableView result;
81563
81564   arg1 = (unsigned int)jarg1;
81565   arg2 = (unsigned int)jarg2;
81566   {
81567     try {
81568       result = Dali::Toolkit::TableView::New(arg1,arg2);
81569     } catch (std::out_of_range& e) {
81570       {
81571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81572       };
81573     } catch (std::exception& e) {
81574       {
81575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81576       };
81577     } catch (Dali::DaliException e) {
81578       {
81579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81580       };
81581     } catch (...) {
81582       {
81583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81584       };
81585     }
81586   }
81587
81588   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81589   return jresult;
81590 }
81591
81592
81593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
81594   void * jresult ;
81595   Dali::BaseHandle arg1 ;
81596   Dali::BaseHandle *argp1 ;
81597   Dali::Toolkit::TableView result;
81598
81599   argp1 = (Dali::BaseHandle *)jarg1;
81600   if (!argp1) {
81601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81602     return 0;
81603   }
81604   arg1 = *argp1;
81605   {
81606     try {
81607       result = Dali::Toolkit::TableView::DownCast(arg1);
81608     } catch (std::out_of_range& e) {
81609       {
81610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81611       };
81612     } catch (std::exception& e) {
81613       {
81614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81615       };
81616     } catch (Dali::DaliException e) {
81617       {
81618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81619       };
81620     } catch (...) {
81621       {
81622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81623       };
81624     }
81625   }
81626
81627   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
81628   return jresult;
81629 }
81630
81631
81632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
81633   unsigned int jresult ;
81634   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81635   Dali::Actor arg2 ;
81636   Dali::Toolkit::TableView::CellPosition arg3 ;
81637   Dali::Actor *argp2 ;
81638   Dali::Toolkit::TableView::CellPosition *argp3 ;
81639   bool result;
81640
81641   arg1 = (Dali::Toolkit::TableView *)jarg1;
81642   argp2 = (Dali::Actor *)jarg2;
81643   if (!argp2) {
81644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81645     return 0;
81646   }
81647   arg2 = *argp2;
81648   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81649   if (!argp3) {
81650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81651     return 0;
81652   }
81653   arg3 = *argp3;
81654   {
81655     try {
81656       result = (bool)(arg1)->AddChild(arg2,arg3);
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 = result;
81677   return jresult;
81678 }
81679
81680
81681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
81682   void * jresult ;
81683   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81684   Dali::Toolkit::TableView::CellPosition arg2 ;
81685   Dali::Toolkit::TableView::CellPosition *argp2 ;
81686   Dali::Actor result;
81687
81688   arg1 = (Dali::Toolkit::TableView *)jarg1;
81689   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81690   if (!argp2) {
81691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81692     return 0;
81693   }
81694   arg2 = *argp2;
81695   {
81696     try {
81697       result = (arg1)->GetChildAt(arg2);
81698     } catch (std::out_of_range& e) {
81699       {
81700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81701       };
81702     } catch (std::exception& e) {
81703       {
81704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81705       };
81706     } catch (Dali::DaliException e) {
81707       {
81708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81709       };
81710     } catch (...) {
81711       {
81712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81713       };
81714     }
81715   }
81716
81717   jresult = new Dali::Actor((const Dali::Actor &)result);
81718   return jresult;
81719 }
81720
81721
81722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
81723   void * jresult ;
81724   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81725   Dali::Toolkit::TableView::CellPosition arg2 ;
81726   Dali::Toolkit::TableView::CellPosition *argp2 ;
81727   Dali::Actor result;
81728
81729   arg1 = (Dali::Toolkit::TableView *)jarg1;
81730   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81731   if (!argp2) {
81732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81733     return 0;
81734   }
81735   arg2 = *argp2;
81736   {
81737     try {
81738       result = (arg1)->RemoveChildAt(arg2);
81739     } catch (std::out_of_range& e) {
81740       {
81741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81742       };
81743     } catch (std::exception& e) {
81744       {
81745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81746       };
81747     } catch (Dali::DaliException e) {
81748       {
81749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81750       };
81751     } catch (...) {
81752       {
81753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81754       };
81755     }
81756   }
81757
81758   jresult = new Dali::Actor((const Dali::Actor &)result);
81759   return jresult;
81760 }
81761
81762
81763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
81764   unsigned int jresult ;
81765   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81766   Dali::Actor arg2 ;
81767   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
81768   Dali::Actor *argp2 ;
81769   bool result;
81770
81771   arg1 = (Dali::Toolkit::TableView *)jarg1;
81772   argp2 = (Dali::Actor *)jarg2;
81773   if (!argp2) {
81774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81775     return 0;
81776   }
81777   arg2 = *argp2;
81778   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
81779   if (!arg3) {
81780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
81781     return 0;
81782   }
81783   {
81784     try {
81785       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
81786     } catch (std::out_of_range& e) {
81787       {
81788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81789       };
81790     } catch (std::exception& e) {
81791       {
81792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81793       };
81794     } catch (Dali::DaliException e) {
81795       {
81796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81797       };
81798     } catch (...) {
81799       {
81800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81801       };
81802     }
81803   }
81804
81805   jresult = result;
81806   return jresult;
81807 }
81808
81809
81810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
81811   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81812   unsigned int arg2 ;
81813
81814   arg1 = (Dali::Toolkit::TableView *)jarg1;
81815   arg2 = (unsigned int)jarg2;
81816   {
81817     try {
81818       (arg1)->InsertRow(arg2);
81819     } catch (std::out_of_range& e) {
81820       {
81821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81822       };
81823     } catch (std::exception& e) {
81824       {
81825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81826       };
81827     } catch (Dali::DaliException e) {
81828       {
81829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81830       };
81831     } catch (...) {
81832       {
81833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81834       };
81835     }
81836   }
81837
81838 }
81839
81840
81841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
81842   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81843   unsigned int arg2 ;
81844
81845   arg1 = (Dali::Toolkit::TableView *)jarg1;
81846   arg2 = (unsigned int)jarg2;
81847   {
81848     try {
81849       (arg1)->DeleteRow(arg2);
81850     } catch (std::out_of_range& e) {
81851       {
81852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81853       };
81854     } catch (std::exception& e) {
81855       {
81856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81857       };
81858     } catch (Dali::DaliException e) {
81859       {
81860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81861       };
81862     } catch (...) {
81863       {
81864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81865       };
81866     }
81867   }
81868
81869 }
81870
81871
81872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81873   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81874   unsigned int arg2 ;
81875   std::vector< Dali::Actor > *arg3 = 0 ;
81876
81877   arg1 = (Dali::Toolkit::TableView *)jarg1;
81878   arg2 = (unsigned int)jarg2;
81879   arg3 = (std::vector< Dali::Actor > *)jarg3;
81880   if (!arg3) {
81881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81882     return ;
81883   }
81884   {
81885     try {
81886       (arg1)->DeleteRow(arg2,*arg3);
81887     } catch (std::out_of_range& e) {
81888       {
81889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81890       };
81891     } catch (std::exception& e) {
81892       {
81893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81894       };
81895     } catch (Dali::DaliException e) {
81896       {
81897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81898       };
81899     } catch (...) {
81900       {
81901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81902       };
81903     }
81904   }
81905
81906 }
81907
81908
81909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
81910   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81911   unsigned int arg2 ;
81912
81913   arg1 = (Dali::Toolkit::TableView *)jarg1;
81914   arg2 = (unsigned int)jarg2;
81915   {
81916     try {
81917       (arg1)->InsertColumn(arg2);
81918     } catch (std::out_of_range& e) {
81919       {
81920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81921       };
81922     } catch (std::exception& e) {
81923       {
81924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81925       };
81926     } catch (Dali::DaliException e) {
81927       {
81928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81929       };
81930     } catch (...) {
81931       {
81932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81933       };
81934     }
81935   }
81936
81937 }
81938
81939
81940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
81941   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81942   unsigned int arg2 ;
81943
81944   arg1 = (Dali::Toolkit::TableView *)jarg1;
81945   arg2 = (unsigned int)jarg2;
81946   {
81947     try {
81948       (arg1)->DeleteColumn(arg2);
81949     } catch (std::out_of_range& e) {
81950       {
81951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81952       };
81953     } catch (std::exception& e) {
81954       {
81955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81956       };
81957     } catch (Dali::DaliException e) {
81958       {
81959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81960       };
81961     } catch (...) {
81962       {
81963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81964       };
81965     }
81966   }
81967
81968 }
81969
81970
81971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
81972   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81973   unsigned int arg2 ;
81974   std::vector< Dali::Actor > *arg3 = 0 ;
81975
81976   arg1 = (Dali::Toolkit::TableView *)jarg1;
81977   arg2 = (unsigned int)jarg2;
81978   arg3 = (std::vector< Dali::Actor > *)jarg3;
81979   if (!arg3) {
81980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
81981     return ;
81982   }
81983   {
81984     try {
81985       (arg1)->DeleteColumn(arg2,*arg3);
81986     } catch (std::out_of_range& e) {
81987       {
81988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81989       };
81990     } catch (std::exception& e) {
81991       {
81992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81993       };
81994     } catch (Dali::DaliException e) {
81995       {
81996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81997       };
81998     } catch (...) {
81999       {
82000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82001       };
82002     }
82003   }
82004
82005 }
82006
82007
82008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82009   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82010   unsigned int arg2 ;
82011   unsigned int arg3 ;
82012
82013   arg1 = (Dali::Toolkit::TableView *)jarg1;
82014   arg2 = (unsigned int)jarg2;
82015   arg3 = (unsigned int)jarg3;
82016   {
82017     try {
82018       (arg1)->Resize(arg2,arg3);
82019     } catch (std::out_of_range& e) {
82020       {
82021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82022       };
82023     } catch (std::exception& e) {
82024       {
82025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82026       };
82027     } catch (Dali::DaliException e) {
82028       {
82029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82030       };
82031     } catch (...) {
82032       {
82033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82034       };
82035     }
82036   }
82037
82038 }
82039
82040
82041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82042   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82043   unsigned int arg2 ;
82044   unsigned int arg3 ;
82045   std::vector< Dali::Actor > *arg4 = 0 ;
82046
82047   arg1 = (Dali::Toolkit::TableView *)jarg1;
82048   arg2 = (unsigned int)jarg2;
82049   arg3 = (unsigned int)jarg3;
82050   arg4 = (std::vector< Dali::Actor > *)jarg4;
82051   if (!arg4) {
82052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82053     return ;
82054   }
82055   {
82056     try {
82057       (arg1)->Resize(arg2,arg3,*arg4);
82058     } catch (std::out_of_range& e) {
82059       {
82060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82061       };
82062     } catch (std::exception& e) {
82063       {
82064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82065       };
82066     } catch (Dali::DaliException e) {
82067       {
82068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82069       };
82070     } catch (...) {
82071       {
82072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82073       };
82074     }
82075   }
82076
82077 }
82078
82079
82080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
82081   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82082   Dali::Size arg2 ;
82083   Dali::Size *argp2 ;
82084
82085   arg1 = (Dali::Toolkit::TableView *)jarg1;
82086   argp2 = (Dali::Size *)jarg2;
82087   if (!argp2) {
82088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
82089     return ;
82090   }
82091   arg2 = *argp2;
82092   {
82093     try {
82094       (arg1)->SetCellPadding(arg2);
82095     } catch (std::out_of_range& e) {
82096       {
82097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82098       };
82099     } catch (std::exception& e) {
82100       {
82101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82102       };
82103     } catch (Dali::DaliException e) {
82104       {
82105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82106       };
82107     } catch (...) {
82108       {
82109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82110       };
82111     }
82112   }
82113
82114 }
82115
82116
82117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
82118   void * jresult ;
82119   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82120   Dali::Size result;
82121
82122   arg1 = (Dali::Toolkit::TableView *)jarg1;
82123   {
82124     try {
82125       result = (arg1)->GetCellPadding();
82126     } catch (std::out_of_range& e) {
82127       {
82128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82129       };
82130     } catch (std::exception& e) {
82131       {
82132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82133       };
82134     } catch (Dali::DaliException e) {
82135       {
82136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82137       };
82138     } catch (...) {
82139       {
82140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82141       };
82142     }
82143   }
82144
82145   jresult = new Dali::Size((const Dali::Size &)result);
82146   return jresult;
82147 }
82148
82149
82150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
82151   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82152   unsigned int arg2 ;
82153
82154   arg1 = (Dali::Toolkit::TableView *)jarg1;
82155   arg2 = (unsigned int)jarg2;
82156   {
82157     try {
82158       (arg1)->SetFitHeight(arg2);
82159     } catch (std::out_of_range& e) {
82160       {
82161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82162       };
82163     } catch (std::exception& e) {
82164       {
82165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82166       };
82167     } catch (Dali::DaliException e) {
82168       {
82169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82170       };
82171     } catch (...) {
82172       {
82173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82174       };
82175     }
82176   }
82177
82178 }
82179
82180
82181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
82182   unsigned int jresult ;
82183   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82184   unsigned int arg2 ;
82185   bool result;
82186
82187   arg1 = (Dali::Toolkit::TableView *)jarg1;
82188   arg2 = (unsigned int)jarg2;
82189   {
82190     try {
82191       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
82192     } catch (std::out_of_range& e) {
82193       {
82194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82195       };
82196     } catch (std::exception& e) {
82197       {
82198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82199       };
82200     } catch (Dali::DaliException e) {
82201       {
82202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82203       };
82204     } catch (...) {
82205       {
82206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82207       };
82208     }
82209   }
82210
82211   jresult = result;
82212   return jresult;
82213 }
82214
82215
82216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
82217   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82218   unsigned int arg2 ;
82219
82220   arg1 = (Dali::Toolkit::TableView *)jarg1;
82221   arg2 = (unsigned int)jarg2;
82222   {
82223     try {
82224       (arg1)->SetFitWidth(arg2);
82225     } catch (std::out_of_range& e) {
82226       {
82227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82228       };
82229     } catch (std::exception& e) {
82230       {
82231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82232       };
82233     } catch (Dali::DaliException e) {
82234       {
82235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82236       };
82237     } catch (...) {
82238       {
82239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82240       };
82241     }
82242   }
82243
82244 }
82245
82246
82247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
82248   unsigned int jresult ;
82249   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82250   unsigned int arg2 ;
82251   bool result;
82252
82253   arg1 = (Dali::Toolkit::TableView *)jarg1;
82254   arg2 = (unsigned int)jarg2;
82255   {
82256     try {
82257       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
82258     } catch (std::out_of_range& e) {
82259       {
82260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82261       };
82262     } catch (std::exception& e) {
82263       {
82264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82265       };
82266     } catch (Dali::DaliException e) {
82267       {
82268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82269       };
82270     } catch (...) {
82271       {
82272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82273       };
82274     }
82275   }
82276
82277   jresult = result;
82278   return jresult;
82279 }
82280
82281
82282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82283   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82284   unsigned int arg2 ;
82285   float arg3 ;
82286
82287   arg1 = (Dali::Toolkit::TableView *)jarg1;
82288   arg2 = (unsigned int)jarg2;
82289   arg3 = (float)jarg3;
82290   {
82291     try {
82292       (arg1)->SetFixedHeight(arg2,arg3);
82293     } catch (std::out_of_range& e) {
82294       {
82295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82296       };
82297     } catch (std::exception& e) {
82298       {
82299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82300       };
82301     } catch (Dali::DaliException e) {
82302       {
82303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82304       };
82305     } catch (...) {
82306       {
82307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82308       };
82309     }
82310   }
82311
82312 }
82313
82314
82315 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
82316   float jresult ;
82317   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82318   unsigned int arg2 ;
82319   float result;
82320
82321   arg1 = (Dali::Toolkit::TableView *)jarg1;
82322   arg2 = (unsigned int)jarg2;
82323   {
82324     try {
82325       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
82326     } catch (std::out_of_range& e) {
82327       {
82328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82329       };
82330     } catch (std::exception& e) {
82331       {
82332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82333       };
82334     } catch (Dali::DaliException e) {
82335       {
82336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82337       };
82338     } catch (...) {
82339       {
82340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82341       };
82342     }
82343   }
82344
82345   jresult = result;
82346   return jresult;
82347 }
82348
82349
82350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
82351   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82352   unsigned int arg2 ;
82353   float arg3 ;
82354
82355   arg1 = (Dali::Toolkit::TableView *)jarg1;
82356   arg2 = (unsigned int)jarg2;
82357   arg3 = (float)jarg3;
82358   {
82359     try {
82360       (arg1)->SetRelativeHeight(arg2,arg3);
82361     } catch (std::out_of_range& e) {
82362       {
82363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82364       };
82365     } catch (std::exception& e) {
82366       {
82367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82368       };
82369     } catch (Dali::DaliException e) {
82370       {
82371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82372       };
82373     } catch (...) {
82374       {
82375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82376       };
82377     }
82378   }
82379
82380 }
82381
82382
82383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
82384   float jresult ;
82385   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82386   unsigned int arg2 ;
82387   float result;
82388
82389   arg1 = (Dali::Toolkit::TableView *)jarg1;
82390   arg2 = (unsigned int)jarg2;
82391   {
82392     try {
82393       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
82394     } catch (std::out_of_range& e) {
82395       {
82396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82397       };
82398     } catch (std::exception& e) {
82399       {
82400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82401       };
82402     } catch (Dali::DaliException e) {
82403       {
82404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82405       };
82406     } catch (...) {
82407       {
82408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82409       };
82410     }
82411   }
82412
82413   jresult = result;
82414   return jresult;
82415 }
82416
82417
82418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82419   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82420   unsigned int arg2 ;
82421   float arg3 ;
82422
82423   arg1 = (Dali::Toolkit::TableView *)jarg1;
82424   arg2 = (unsigned int)jarg2;
82425   arg3 = (float)jarg3;
82426   {
82427     try {
82428       (arg1)->SetFixedWidth(arg2,arg3);
82429     } catch (std::out_of_range& e) {
82430       {
82431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82432       };
82433     } catch (std::exception& e) {
82434       {
82435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82436       };
82437     } catch (Dali::DaliException e) {
82438       {
82439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82440       };
82441     } catch (...) {
82442       {
82443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82444       };
82445     }
82446   }
82447
82448 }
82449
82450
82451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
82452   float jresult ;
82453   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82454   unsigned int arg2 ;
82455   float result;
82456
82457   arg1 = (Dali::Toolkit::TableView *)jarg1;
82458   arg2 = (unsigned int)jarg2;
82459   {
82460     try {
82461       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
82462     } catch (std::out_of_range& e) {
82463       {
82464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82465       };
82466     } catch (std::exception& e) {
82467       {
82468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82469       };
82470     } catch (Dali::DaliException e) {
82471       {
82472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82473       };
82474     } catch (...) {
82475       {
82476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82477       };
82478     }
82479   }
82480
82481   jresult = result;
82482   return jresult;
82483 }
82484
82485
82486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
82487   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82488   unsigned int arg2 ;
82489   float arg3 ;
82490
82491   arg1 = (Dali::Toolkit::TableView *)jarg1;
82492   arg2 = (unsigned int)jarg2;
82493   arg3 = (float)jarg3;
82494   {
82495     try {
82496       (arg1)->SetRelativeWidth(arg2,arg3);
82497     } catch (std::out_of_range& e) {
82498       {
82499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82500       };
82501     } catch (std::exception& e) {
82502       {
82503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82504       };
82505     } catch (Dali::DaliException e) {
82506       {
82507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82508       };
82509     } catch (...) {
82510       {
82511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82512       };
82513     }
82514   }
82515
82516 }
82517
82518
82519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
82520   float jresult ;
82521   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82522   unsigned int arg2 ;
82523   float result;
82524
82525   arg1 = (Dali::Toolkit::TableView *)jarg1;
82526   arg2 = (unsigned int)jarg2;
82527   {
82528     try {
82529       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
82530     } catch (std::out_of_range& e) {
82531       {
82532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82533       };
82534     } catch (std::exception& e) {
82535       {
82536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82537       };
82538     } catch (Dali::DaliException e) {
82539       {
82540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82541       };
82542     } catch (...) {
82543       {
82544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82545       };
82546     }
82547   }
82548
82549   jresult = result;
82550   return jresult;
82551 }
82552
82553
82554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
82555   unsigned int jresult ;
82556   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82557   unsigned int result;
82558
82559   arg1 = (Dali::Toolkit::TableView *)jarg1;
82560   {
82561     try {
82562       result = (unsigned int)(arg1)->GetRows();
82563     } catch (std::out_of_range& e) {
82564       {
82565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82566       };
82567     } catch (std::exception& e) {
82568       {
82569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82570       };
82571     } catch (Dali::DaliException e) {
82572       {
82573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82574       };
82575     } catch (...) {
82576       {
82577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82578       };
82579     }
82580   }
82581
82582   jresult = result;
82583   return jresult;
82584 }
82585
82586
82587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
82588   unsigned int jresult ;
82589   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82590   unsigned int result;
82591
82592   arg1 = (Dali::Toolkit::TableView *)jarg1;
82593   {
82594     try {
82595       result = (unsigned int)(arg1)->GetColumns();
82596     } catch (std::out_of_range& e) {
82597       {
82598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82599       };
82600     } catch (std::exception& e) {
82601       {
82602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82603       };
82604     } catch (Dali::DaliException e) {
82605       {
82606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82607       };
82608     } catch (...) {
82609       {
82610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82611       };
82612     }
82613   }
82614
82615   jresult = result;
82616   return jresult;
82617 }
82618
82619
82620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
82621   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82622   Dali::Toolkit::TableView::CellPosition arg2 ;
82623   Dali::HorizontalAlignment::Type arg3 ;
82624   Dali::VerticalAlignment::Type arg4 ;
82625   Dali::Toolkit::TableView::CellPosition *argp2 ;
82626
82627   arg1 = (Dali::Toolkit::TableView *)jarg1;
82628   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82629   if (!argp2) {
82630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82631     return ;
82632   }
82633   arg2 = *argp2;
82634   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
82635   arg4 = (Dali::VerticalAlignment::Type)jarg4;
82636   {
82637     try {
82638       (arg1)->SetCellAlignment(arg2,arg3,arg4);
82639     } catch (std::out_of_range& e) {
82640       {
82641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82642       };
82643     } catch (std::exception& e) {
82644       {
82645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82646       };
82647     } catch (Dali::DaliException e) {
82648       {
82649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82650       };
82651     } catch (...) {
82652       {
82653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82654       };
82655     }
82656   }
82657
82658 }
82659
82660
82661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
82662   unsigned int jresult ;
82663   unsigned int result;
82664
82665   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
82666   jresult = result;
82667   return jresult;
82668 }
82669
82670
82671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
82672   int jresult ;
82673   int result;
82674
82675   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
82676   jresult = (int)result;
82677   return jresult;
82678 }
82679
82680
82681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
82682   int jresult ;
82683   int result;
82684
82685   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
82686   jresult = (int)result;
82687   return jresult;
82688 }
82689
82690
82691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
82692   int jresult ;
82693   int result;
82694
82695   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
82696   jresult = (int)result;
82697   return jresult;
82698 }
82699
82700
82701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
82702   int jresult ;
82703   int result;
82704
82705   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
82706   jresult = (int)result;
82707   return jresult;
82708 }
82709
82710
82711 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
82712   int jresult ;
82713   int result;
82714
82715   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
82716   jresult = (int)result;
82717   return jresult;
82718 }
82719
82720
82721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
82722   int jresult ;
82723   int result;
82724
82725   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
82726   jresult = (int)result;
82727   return jresult;
82728 }
82729
82730
82731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
82732   int jresult ;
82733   int result;
82734
82735   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
82736   jresult = (int)result;
82737   return jresult;
82738 }
82739
82740
82741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
82742   int jresult ;
82743   int result;
82744
82745   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
82746   jresult = (int)result;
82747   return jresult;
82748 }
82749
82750
82751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
82752   int jresult ;
82753   int result;
82754
82755   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
82756   jresult = (int)result;
82757   return jresult;
82758 }
82759
82760
82761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
82762   int jresult ;
82763   int result;
82764
82765   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
82766   jresult = (int)result;
82767   return jresult;
82768 }
82769
82770
82771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
82772   int jresult ;
82773   int result;
82774
82775   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
82776   jresult = (int)result;
82777   return jresult;
82778 }
82779
82780
82781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
82782   int jresult ;
82783   int result;
82784
82785   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
82786   jresult = (int)result;
82787   return jresult;
82788 }
82789
82790
82791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
82792   int jresult ;
82793   int result;
82794
82795   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
82796   jresult = (int)result;
82797   return jresult;
82798 }
82799
82800
82801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
82802   int jresult ;
82803   int result;
82804
82805   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
82806   jresult = (int)result;
82807   return jresult;
82808 }
82809
82810
82811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
82812   int jresult ;
82813   int result;
82814
82815   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
82816   jresult = (int)result;
82817   return jresult;
82818 }
82819
82820
82821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
82822   int jresult ;
82823   int result;
82824
82825   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
82826   jresult = (int)result;
82827   return jresult;
82828 }
82829
82830
82831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
82832   int jresult ;
82833   int result;
82834
82835   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
82836   jresult = (int)result;
82837   return jresult;
82838 }
82839
82840
82841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
82842   int jresult ;
82843   int result;
82844
82845   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
82846   jresult = (int)result;
82847   return jresult;
82848 }
82849
82850
82851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
82852   int jresult ;
82853   int result;
82854
82855   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
82856   jresult = (int)result;
82857   return jresult;
82858 }
82859
82860
82861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
82862   void * jresult ;
82863   Dali::Toolkit::TextLabel::Property *result = 0 ;
82864
82865   {
82866     try {
82867       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
82868     } catch (std::out_of_range& e) {
82869       {
82870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82871       };
82872     } catch (std::exception& e) {
82873       {
82874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82875       };
82876     } catch (Dali::DaliException e) {
82877       {
82878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82879       };
82880     } catch (...) {
82881       {
82882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82883       };
82884     }
82885   }
82886
82887   jresult = (void *)result;
82888   return jresult;
82889 }
82890
82891
82892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
82893   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
82894
82895   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
82896   {
82897     try {
82898       delete arg1;
82899     } catch (std::out_of_range& e) {
82900       {
82901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82902       };
82903     } catch (std::exception& e) {
82904       {
82905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82906       };
82907     } catch (Dali::DaliException e) {
82908       {
82909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82910       };
82911     } catch (...) {
82912       {
82913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82914       };
82915     }
82916   }
82917
82918 }
82919
82920
82921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
82922   void * jresult ;
82923   Dali::Toolkit::TextLabel result;
82924
82925   {
82926     try {
82927       result = Dali::Toolkit::TextLabel::New();
82928     } catch (std::out_of_range& e) {
82929       {
82930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82931       };
82932     } catch (std::exception& e) {
82933       {
82934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82935       };
82936     } catch (Dali::DaliException e) {
82937       {
82938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82939       };
82940     } catch (...) {
82941       {
82942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82943       };
82944     }
82945   }
82946
82947   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82948   return jresult;
82949 }
82950
82951
82952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
82953   void * jresult ;
82954   std::string *arg1 = 0 ;
82955   Dali::Toolkit::TextLabel result;
82956
82957   if (!jarg1) {
82958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82959     return 0;
82960   }
82961   std::string arg1_str(jarg1);
82962   arg1 = &arg1_str;
82963   {
82964     try {
82965       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
82966     } catch (std::out_of_range& e) {
82967       {
82968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82969       };
82970     } catch (std::exception& e) {
82971       {
82972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82973       };
82974     } catch (Dali::DaliException e) {
82975       {
82976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82977       };
82978     } catch (...) {
82979       {
82980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82981       };
82982     }
82983   }
82984
82985   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
82986
82987   //argout typemap for const std::string&
82988
82989   return jresult;
82990 }
82991
82992
82993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
82994   void * jresult ;
82995   Dali::Toolkit::TextLabel *result = 0 ;
82996
82997   {
82998     try {
82999       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83000     } catch (std::out_of_range& e) {
83001       {
83002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83003       };
83004     } catch (std::exception& e) {
83005       {
83006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83007       };
83008     } catch (Dali::DaliException e) {
83009       {
83010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83011       };
83012     } catch (...) {
83013       {
83014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83015       };
83016     }
83017   }
83018
83019   jresult = (void *)result;
83020   return jresult;
83021 }
83022
83023
83024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83025   void * jresult ;
83026   Dali::Toolkit::TextLabel *arg1 = 0 ;
83027   Dali::Toolkit::TextLabel *result = 0 ;
83028
83029   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83030   if (!arg1) {
83031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83032     return 0;
83033   }
83034   {
83035     try {
83036       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83037     } catch (std::out_of_range& e) {
83038       {
83039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83040       };
83041     } catch (std::exception& e) {
83042       {
83043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83044       };
83045     } catch (Dali::DaliException e) {
83046       {
83047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83048       };
83049     } catch (...) {
83050       {
83051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83052       };
83053     }
83054   }
83055
83056   jresult = (void *)result;
83057   return jresult;
83058 }
83059
83060
83061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83062   void * jresult ;
83063   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83064   Dali::Toolkit::TextLabel *arg2 = 0 ;
83065   Dali::Toolkit::TextLabel *result = 0 ;
83066
83067   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83068   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
83069   if (!arg2) {
83070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83071     return 0;
83072   }
83073   {
83074     try {
83075       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
83076     } catch (std::out_of_range& e) {
83077       {
83078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83079       };
83080     } catch (std::exception& e) {
83081       {
83082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83083       };
83084     } catch (Dali::DaliException e) {
83085       {
83086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83087       };
83088     } catch (...) {
83089       {
83090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83091       };
83092     }
83093   }
83094
83095   jresult = (void *)result;
83096   return jresult;
83097 }
83098
83099
83100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
83101   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83102
83103   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83104   {
83105     try {
83106       delete arg1;
83107     } catch (std::out_of_range& e) {
83108       {
83109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83110       };
83111     } catch (std::exception& e) {
83112       {
83113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83114       };
83115     } catch (Dali::DaliException e) {
83116       {
83117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83118       };
83119     } catch (...) {
83120       {
83121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83122       };
83123     }
83124   }
83125
83126 }
83127
83128
83129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
83130   void * jresult ;
83131   Dali::BaseHandle arg1 ;
83132   Dali::BaseHandle *argp1 ;
83133   Dali::Toolkit::TextLabel result;
83134
83135   argp1 = (Dali::BaseHandle *)jarg1;
83136   if (!argp1) {
83137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83138     return 0;
83139   }
83140   arg1 = *argp1;
83141   {
83142     try {
83143       result = Dali::Toolkit::TextLabel::DownCast(arg1);
83144     } catch (std::out_of_range& e) {
83145       {
83146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83147       };
83148     } catch (std::exception& e) {
83149       {
83150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83151       };
83152     } catch (Dali::DaliException e) {
83153       {
83154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83155       };
83156     } catch (...) {
83157       {
83158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83159       };
83160     }
83161   }
83162
83163   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83164   return jresult;
83165 }
83166
83167
83168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
83169   void * jresult ;
83170   Dali::Toolkit::AccessibilityManager *result = 0 ;
83171
83172   {
83173     try {
83174       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
83175     } catch (std::out_of_range& e) {
83176       {
83177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83178       };
83179     } catch (std::exception& e) {
83180       {
83181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83182       };
83183     } catch (Dali::DaliException e) {
83184       {
83185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83186       };
83187     } catch (...) {
83188       {
83189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83190       };
83191     }
83192   }
83193
83194   jresult = (void *)result;
83195   return jresult;
83196 }
83197
83198
83199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
83200   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83201
83202   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83203   {
83204     try {
83205       delete arg1;
83206     } catch (std::out_of_range& e) {
83207       {
83208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83209       };
83210     } catch (std::exception& e) {
83211       {
83212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83213       };
83214     } catch (Dali::DaliException e) {
83215       {
83216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83217       };
83218     } catch (...) {
83219       {
83220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83221       };
83222     }
83223   }
83224
83225 }
83226
83227
83228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
83229   void * jresult ;
83230   Dali::Toolkit::AccessibilityManager result;
83231
83232   {
83233     try {
83234       result = Dali::Toolkit::AccessibilityManager::Get();
83235     } catch (std::out_of_range& e) {
83236       {
83237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83238       };
83239     } catch (std::exception& e) {
83240       {
83241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83242       };
83243     } catch (Dali::DaliException e) {
83244       {
83245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83246       };
83247     } catch (...) {
83248       {
83249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83250       };
83251     }
83252   }
83253
83254   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
83255   return jresult;
83256 }
83257
83258
83259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
83260   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83261   Dali::Actor arg2 ;
83262   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83263   std::string *arg4 = 0 ;
83264   Dali::Actor *argp2 ;
83265
83266   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83267   argp2 = (Dali::Actor *)jarg2;
83268   if (!argp2) {
83269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83270     return ;
83271   }
83272   arg2 = *argp2;
83273   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83274   if (!jarg4) {
83275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83276     return ;
83277   }
83278   std::string arg4_str(jarg4);
83279   arg4 = &arg4_str;
83280   {
83281     try {
83282       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
83283     } catch (std::out_of_range& e) {
83284       {
83285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83286       };
83287     } catch (std::exception& e) {
83288       {
83289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83290       };
83291     } catch (Dali::DaliException e) {
83292       {
83293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83294       };
83295     } catch (...) {
83296       {
83297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83298       };
83299     }
83300   }
83301
83302
83303   //argout typemap for const std::string&
83304
83305 }
83306
83307
83308 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
83309   char * jresult ;
83310   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83311   Dali::Actor arg2 ;
83312   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
83313   Dali::Actor *argp2 ;
83314   std::string result;
83315
83316   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83317   argp2 = (Dali::Actor *)jarg2;
83318   if (!argp2) {
83319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83320     return 0;
83321   }
83322   arg2 = *argp2;
83323   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
83324   {
83325     try {
83326       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
83327     } catch (std::out_of_range& e) {
83328       {
83329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83330       };
83331     } catch (std::exception& e) {
83332       {
83333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83334       };
83335     } catch (Dali::DaliException e) {
83336       {
83337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83338       };
83339     } catch (...) {
83340       {
83341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83342       };
83343     }
83344   }
83345
83346   jresult = SWIG_csharp_string_callback((&result)->c_str());
83347   return jresult;
83348 }
83349
83350
83351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
83352   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83353   Dali::Actor arg2 ;
83354   unsigned int arg3 ;
83355   Dali::Actor *argp2 ;
83356
83357   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83358   argp2 = (Dali::Actor *)jarg2;
83359   if (!argp2) {
83360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83361     return ;
83362   }
83363   arg2 = *argp2;
83364   arg3 = (unsigned int)jarg3;
83365   {
83366     try {
83367       (arg1)->SetFocusOrder(arg2,arg3);
83368     } catch (std::out_of_range& e) {
83369       {
83370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83371       };
83372     } catch (std::exception& e) {
83373       {
83374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83375       };
83376     } catch (Dali::DaliException e) {
83377       {
83378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83379       };
83380     } catch (...) {
83381       {
83382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83383       };
83384     }
83385   }
83386
83387 }
83388
83389
83390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
83391   unsigned int jresult ;
83392   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83393   Dali::Actor arg2 ;
83394   Dali::Actor *argp2 ;
83395   unsigned int result;
83396
83397   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83398   argp2 = (Dali::Actor *)jarg2;
83399   if (!argp2) {
83400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83401     return 0;
83402   }
83403   arg2 = *argp2;
83404   {
83405     try {
83406       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
83407     } catch (std::out_of_range& e) {
83408       {
83409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83410       };
83411     } catch (std::exception& e) {
83412       {
83413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83414       };
83415     } catch (Dali::DaliException e) {
83416       {
83417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83418       };
83419     } catch (...) {
83420       {
83421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83422       };
83423     }
83424   }
83425
83426   jresult = result;
83427   return jresult;
83428 }
83429
83430
83431 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
83432   unsigned int jresult ;
83433   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83434   unsigned int result;
83435
83436   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83437   {
83438     try {
83439       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
83440     } catch (std::out_of_range& e) {
83441       {
83442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83443       };
83444     } catch (std::exception& e) {
83445       {
83446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83447       };
83448     } catch (Dali::DaliException e) {
83449       {
83450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83451       };
83452     } catch (...) {
83453       {
83454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83455       };
83456     }
83457   }
83458
83459   jresult = result;
83460   return jresult;
83461 }
83462
83463
83464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
83465   void * jresult ;
83466   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83467   unsigned int arg2 ;
83468   Dali::Actor result;
83469
83470   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83471   arg2 = (unsigned int)jarg2;
83472   {
83473     try {
83474       result = (arg1)->GetActorByFocusOrder(arg2);
83475     } catch (std::out_of_range& e) {
83476       {
83477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83478       };
83479     } catch (std::exception& e) {
83480       {
83481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83482       };
83483     } catch (Dali::DaliException e) {
83484       {
83485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83486       };
83487     } catch (...) {
83488       {
83489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83490       };
83491     }
83492   }
83493
83494   jresult = new Dali::Actor((const Dali::Actor &)result);
83495   return jresult;
83496 }
83497
83498
83499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
83500   unsigned int jresult ;
83501   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83502   Dali::Actor arg2 ;
83503   Dali::Actor *argp2 ;
83504   bool result;
83505
83506   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83507   argp2 = (Dali::Actor *)jarg2;
83508   if (!argp2) {
83509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83510     return 0;
83511   }
83512   arg2 = *argp2;
83513   {
83514     try {
83515       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
83516     } catch (std::out_of_range& e) {
83517       {
83518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83519       };
83520     } catch (std::exception& e) {
83521       {
83522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83523       };
83524     } catch (Dali::DaliException e) {
83525       {
83526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83527       };
83528     } catch (...) {
83529       {
83530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83531       };
83532     }
83533   }
83534
83535   jresult = result;
83536   return jresult;
83537 }
83538
83539
83540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
83541   void * jresult ;
83542   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83543   Dali::Actor result;
83544
83545   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83546   {
83547     try {
83548       result = (arg1)->GetCurrentFocusActor();
83549     } catch (std::out_of_range& e) {
83550       {
83551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83552       };
83553     } catch (std::exception& e) {
83554       {
83555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83556       };
83557     } catch (Dali::DaliException e) {
83558       {
83559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83560       };
83561     } catch (...) {
83562       {
83563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83564       };
83565     }
83566   }
83567
83568   jresult = new Dali::Actor((const Dali::Actor &)result);
83569   return jresult;
83570 }
83571
83572
83573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
83574   void * jresult ;
83575   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83576   Dali::Actor result;
83577
83578   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83579   {
83580     try {
83581       result = (arg1)->GetCurrentFocusGroup();
83582     } catch (std::out_of_range& e) {
83583       {
83584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83585       };
83586     } catch (std::exception& e) {
83587       {
83588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83589       };
83590     } catch (Dali::DaliException e) {
83591       {
83592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83593       };
83594     } catch (...) {
83595       {
83596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83597       };
83598     }
83599   }
83600
83601   jresult = new Dali::Actor((const Dali::Actor &)result);
83602   return jresult;
83603 }
83604
83605
83606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
83607   unsigned int jresult ;
83608   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83609   unsigned int result;
83610
83611   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83612   {
83613     try {
83614       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
83615     } catch (std::out_of_range& e) {
83616       {
83617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83618       };
83619     } catch (std::exception& e) {
83620       {
83621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83622       };
83623     } catch (Dali::DaliException e) {
83624       {
83625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83626       };
83627     } catch (...) {
83628       {
83629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83630       };
83631     }
83632   }
83633
83634   jresult = result;
83635   return jresult;
83636 }
83637
83638
83639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
83640   unsigned int jresult ;
83641   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83642   bool result;
83643
83644   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83645   {
83646     try {
83647       result = (bool)(arg1)->MoveFocusForward();
83648     } catch (std::out_of_range& e) {
83649       {
83650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83651       };
83652     } catch (std::exception& e) {
83653       {
83654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83655       };
83656     } catch (Dali::DaliException e) {
83657       {
83658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83659       };
83660     } catch (...) {
83661       {
83662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83663       };
83664     }
83665   }
83666
83667   jresult = result;
83668   return jresult;
83669 }
83670
83671
83672 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
83673   unsigned int jresult ;
83674   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83675   bool result;
83676
83677   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83678   {
83679     try {
83680       result = (bool)(arg1)->MoveFocusBackward();
83681     } catch (std::out_of_range& e) {
83682       {
83683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83684       };
83685     } catch (std::exception& e) {
83686       {
83687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83688       };
83689     } catch (Dali::DaliException e) {
83690       {
83691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83692       };
83693     } catch (...) {
83694       {
83695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83696       };
83697     }
83698   }
83699
83700   jresult = result;
83701   return jresult;
83702 }
83703
83704
83705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
83706   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83707
83708   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83709   {
83710     try {
83711       (arg1)->ClearFocus();
83712     } catch (std::out_of_range& e) {
83713       {
83714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83715       };
83716     } catch (std::exception& e) {
83717       {
83718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83719       };
83720     } catch (Dali::DaliException e) {
83721       {
83722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83723       };
83724     } catch (...) {
83725       {
83726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83727       };
83728     }
83729   }
83730
83731 }
83732
83733
83734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
83735   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83736
83737   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83738   {
83739     try {
83740       (arg1)->Reset();
83741     } catch (std::out_of_range& e) {
83742       {
83743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83744       };
83745     } catch (std::exception& e) {
83746       {
83747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83748       };
83749     } catch (Dali::DaliException e) {
83750       {
83751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83752       };
83753     } catch (...) {
83754       {
83755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83756       };
83757     }
83758   }
83759
83760 }
83761
83762
83763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
83764   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83765   Dali::Actor arg2 ;
83766   bool arg3 ;
83767   Dali::Actor *argp2 ;
83768
83769   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83770   argp2 = (Dali::Actor *)jarg2;
83771   if (!argp2) {
83772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83773     return ;
83774   }
83775   arg2 = *argp2;
83776   arg3 = jarg3 ? true : false;
83777   {
83778     try {
83779       (arg1)->SetFocusGroup(arg2,arg3);
83780     } catch (std::out_of_range& e) {
83781       {
83782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83783       };
83784     } catch (std::exception& e) {
83785       {
83786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83787       };
83788     } catch (Dali::DaliException e) {
83789       {
83790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83791       };
83792     } catch (...) {
83793       {
83794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83795       };
83796     }
83797   }
83798
83799 }
83800
83801
83802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
83803   unsigned int jresult ;
83804   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83805   Dali::Actor arg2 ;
83806   Dali::Actor *argp2 ;
83807   bool result;
83808
83809   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83810   argp2 = (Dali::Actor *)jarg2;
83811   if (!argp2) {
83812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83813     return 0;
83814   }
83815   arg2 = *argp2;
83816   {
83817     try {
83818       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
83819     } catch (std::out_of_range& e) {
83820       {
83821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83822       };
83823     } catch (std::exception& e) {
83824       {
83825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83826       };
83827     } catch (Dali::DaliException e) {
83828       {
83829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83830       };
83831     } catch (...) {
83832       {
83833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83834       };
83835     }
83836   }
83837
83838   jresult = result;
83839   return jresult;
83840 }
83841
83842
83843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
83844   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83845   bool arg2 ;
83846
83847   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83848   arg2 = jarg2 ? true : false;
83849   {
83850     try {
83851       (arg1)->SetGroupMode(arg2);
83852     } catch (std::out_of_range& e) {
83853       {
83854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83855       };
83856     } catch (std::exception& e) {
83857       {
83858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83859       };
83860     } catch (Dali::DaliException e) {
83861       {
83862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83863       };
83864     } catch (...) {
83865       {
83866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83867       };
83868     }
83869   }
83870
83871 }
83872
83873
83874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
83875   unsigned int jresult ;
83876   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83877   bool result;
83878
83879   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83880   {
83881     try {
83882       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
83883     } catch (std::out_of_range& e) {
83884       {
83885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83886       };
83887     } catch (std::exception& e) {
83888       {
83889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83890       };
83891     } catch (Dali::DaliException e) {
83892       {
83893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83894       };
83895     } catch (...) {
83896       {
83897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83898       };
83899     }
83900   }
83901
83902   jresult = result;
83903   return jresult;
83904 }
83905
83906
83907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
83908   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83909   bool arg2 ;
83910
83911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83912   arg2 = jarg2 ? true : false;
83913   {
83914     try {
83915       (arg1)->SetWrapMode(arg2);
83916     } catch (std::out_of_range& e) {
83917       {
83918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83919       };
83920     } catch (std::exception& e) {
83921       {
83922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83923       };
83924     } catch (Dali::DaliException e) {
83925       {
83926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83927       };
83928     } catch (...) {
83929       {
83930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83931       };
83932     }
83933   }
83934
83935 }
83936
83937
83938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
83939   unsigned int jresult ;
83940   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83941   bool result;
83942
83943   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83944   {
83945     try {
83946       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
83947     } catch (std::out_of_range& e) {
83948       {
83949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83950       };
83951     } catch (std::exception& e) {
83952       {
83953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83954       };
83955     } catch (Dali::DaliException e) {
83956       {
83957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83958       };
83959     } catch (...) {
83960       {
83961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83962       };
83963     }
83964   }
83965
83966   jresult = result;
83967   return jresult;
83968 }
83969
83970
83971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
83972   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83973   Dali::Actor arg2 ;
83974   Dali::Actor *argp2 ;
83975
83976   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83977   argp2 = (Dali::Actor *)jarg2;
83978   if (!argp2) {
83979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83980     return ;
83981   }
83982   arg2 = *argp2;
83983   {
83984     try {
83985       (arg1)->SetFocusIndicatorActor(arg2);
83986     } catch (std::out_of_range& e) {
83987       {
83988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83989       };
83990     } catch (std::exception& e) {
83991       {
83992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83993       };
83994     } catch (Dali::DaliException e) {
83995       {
83996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83997       };
83998     } catch (...) {
83999       {
84000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84001       };
84002     }
84003   }
84004
84005 }
84006
84007
84008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84009   void * jresult ;
84010   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84011   Dali::Actor result;
84012
84013   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84014   {
84015     try {
84016       result = (arg1)->GetFocusIndicatorActor();
84017     } catch (std::out_of_range& e) {
84018       {
84019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84020       };
84021     } catch (std::exception& e) {
84022       {
84023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84024       };
84025     } catch (Dali::DaliException e) {
84026       {
84027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84028       };
84029     } catch (...) {
84030       {
84031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84032       };
84033     }
84034   }
84035
84036   jresult = new Dali::Actor((const Dali::Actor &)result);
84037   return jresult;
84038 }
84039
84040
84041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84042   void * jresult ;
84043   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84044   Dali::Actor arg2 ;
84045   Dali::Actor *argp2 ;
84046   Dali::Actor result;
84047
84048   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84049   argp2 = (Dali::Actor *)jarg2;
84050   if (!argp2) {
84051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84052     return 0;
84053   }
84054   arg2 = *argp2;
84055   {
84056     try {
84057       result = (arg1)->GetFocusGroup(arg2);
84058     } catch (std::out_of_range& e) {
84059       {
84060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84061       };
84062     } catch (std::exception& e) {
84063       {
84064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84065       };
84066     } catch (Dali::DaliException e) {
84067       {
84068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84069       };
84070     } catch (...) {
84071       {
84072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84073       };
84074     }
84075   }
84076
84077   jresult = new Dali::Actor((const Dali::Actor &)result);
84078   return jresult;
84079 }
84080
84081
84082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
84083   void * jresult ;
84084   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84085   Dali::Vector2 result;
84086
84087   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84088   {
84089     try {
84090       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
84091     } catch (std::out_of_range& e) {
84092       {
84093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84094       };
84095     } catch (std::exception& e) {
84096       {
84097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84098       };
84099     } catch (Dali::DaliException e) {
84100       {
84101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84102       };
84103     } catch (...) {
84104       {
84105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84106       };
84107     }
84108   }
84109
84110   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
84111   return jresult;
84112 }
84113
84114
84115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
84116   void * jresult ;
84117   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84118   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
84119
84120   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84121   {
84122     try {
84123       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
84124     } catch (std::out_of_range& e) {
84125       {
84126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84127       };
84128     } catch (std::exception& e) {
84129       {
84130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84131       };
84132     } catch (Dali::DaliException e) {
84133       {
84134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84135       };
84136     } catch (...) {
84137       {
84138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84139       };
84140     }
84141   }
84142
84143   jresult = (void *)result;
84144   return jresult;
84145 }
84146
84147
84148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
84149   void * jresult ;
84150   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84151   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
84152
84153   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84154   {
84155     try {
84156       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
84157     } catch (std::out_of_range& e) {
84158       {
84159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84160       };
84161     } catch (std::exception& e) {
84162       {
84163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84164       };
84165     } catch (Dali::DaliException e) {
84166       {
84167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84168       };
84169     } catch (...) {
84170       {
84171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84172       };
84173     }
84174   }
84175
84176   jresult = (void *)result;
84177   return jresult;
84178 }
84179
84180
84181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
84182   void * jresult ;
84183   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84184   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
84185
84186   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84187   {
84188     try {
84189       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
84190     } catch (std::out_of_range& e) {
84191       {
84192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84193       };
84194     } catch (std::exception& e) {
84195       {
84196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84197       };
84198     } catch (Dali::DaliException e) {
84199       {
84200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84201       };
84202     } catch (...) {
84203       {
84204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84205       };
84206     }
84207   }
84208
84209   jresult = (void *)result;
84210   return jresult;
84211 }
84212
84213
84214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
84215   void * jresult ;
84216   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84217   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84218
84219   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84220   {
84221     try {
84222       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
84223     } catch (std::out_of_range& e) {
84224       {
84225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84226       };
84227     } catch (std::exception& e) {
84228       {
84229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84230       };
84231     } catch (Dali::DaliException e) {
84232       {
84233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84234       };
84235     } catch (...) {
84236       {
84237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84238       };
84239     }
84240   }
84241
84242   jresult = (void *)result;
84243   return jresult;
84244 }
84245
84246
84247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
84248   void * jresult ;
84249   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84250   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84251
84252   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84253   {
84254     try {
84255       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
84256     } catch (std::out_of_range& e) {
84257       {
84258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84259       };
84260     } catch (std::exception& e) {
84261       {
84262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84263       };
84264     } catch (Dali::DaliException e) {
84265       {
84266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84267       };
84268     } catch (...) {
84269       {
84270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84271       };
84272     }
84273   }
84274
84275   jresult = (void *)result;
84276   return jresult;
84277 }
84278
84279
84280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
84281   void * jresult ;
84282   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84283   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84284
84285   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84286   {
84287     try {
84288       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
84289     } catch (std::out_of_range& e) {
84290       {
84291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84292       };
84293     } catch (std::exception& e) {
84294       {
84295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84296       };
84297     } catch (Dali::DaliException e) {
84298       {
84299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84300       };
84301     } catch (...) {
84302       {
84303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84304       };
84305     }
84306   }
84307
84308   jresult = (void *)result;
84309   return jresult;
84310 }
84311
84312
84313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
84314   void * jresult ;
84315   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84316   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84317
84318   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84319   {
84320     try {
84321       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
84322     } catch (std::out_of_range& e) {
84323       {
84324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84325       };
84326     } catch (std::exception& e) {
84327       {
84328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84329       };
84330     } catch (Dali::DaliException e) {
84331       {
84332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84333       };
84334     } catch (...) {
84335       {
84336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84337       };
84338     }
84339   }
84340
84341   jresult = (void *)result;
84342   return jresult;
84343 }
84344
84345
84346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
84347   void * jresult ;
84348   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84349   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84350
84351   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84352   {
84353     try {
84354       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
84355     } catch (std::out_of_range& e) {
84356       {
84357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84358       };
84359     } catch (std::exception& e) {
84360       {
84361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84362       };
84363     } catch (Dali::DaliException e) {
84364       {
84365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84366       };
84367     } catch (...) {
84368       {
84369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84370       };
84371     }
84372   }
84373
84374   jresult = (void *)result;
84375   return jresult;
84376 }
84377
84378
84379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
84380   void * jresult ;
84381   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84382   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84383
84384   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84385   {
84386     try {
84387       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
84388     } catch (std::out_of_range& e) {
84389       {
84390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84391       };
84392     } catch (std::exception& e) {
84393       {
84394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84395       };
84396     } catch (Dali::DaliException e) {
84397       {
84398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84399       };
84400     } catch (...) {
84401       {
84402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84403       };
84404     }
84405   }
84406
84407   jresult = (void *)result;
84408   return jresult;
84409 }
84410
84411
84412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
84413   void * jresult ;
84414   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84415   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84416
84417   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84418   {
84419     try {
84420       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
84421     } catch (std::out_of_range& e) {
84422       {
84423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84424       };
84425     } catch (std::exception& e) {
84426       {
84427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84428       };
84429     } catch (Dali::DaliException e) {
84430       {
84431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84432       };
84433     } catch (...) {
84434       {
84435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84436       };
84437     }
84438   }
84439
84440   jresult = (void *)result;
84441   return jresult;
84442 }
84443
84444
84445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
84446   void * jresult ;
84447   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84448   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84449
84450   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84451   {
84452     try {
84453       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
84454     } catch (std::out_of_range& e) {
84455       {
84456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84457       };
84458     } catch (std::exception& e) {
84459       {
84460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84461       };
84462     } catch (Dali::DaliException e) {
84463       {
84464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84465       };
84466     } catch (...) {
84467       {
84468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84469       };
84470     }
84471   }
84472
84473   jresult = (void *)result;
84474   return jresult;
84475 }
84476
84477
84478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
84479   void * jresult ;
84480   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84481   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84482
84483   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84484   {
84485     try {
84486       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
84487     } catch (std::out_of_range& e) {
84488       {
84489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84490       };
84491     } catch (std::exception& e) {
84492       {
84493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84494       };
84495     } catch (Dali::DaliException e) {
84496       {
84497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84498       };
84499     } catch (...) {
84500       {
84501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84502       };
84503     }
84504   }
84505
84506   jresult = (void *)result;
84507   return jresult;
84508 }
84509
84510
84511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
84512   void * jresult ;
84513   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84514   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84515
84516   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84517   {
84518     try {
84519       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
84520     } catch (std::out_of_range& e) {
84521       {
84522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84523       };
84524     } catch (std::exception& e) {
84525       {
84526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84527       };
84528     } catch (Dali::DaliException e) {
84529       {
84530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84531       };
84532     } catch (...) {
84533       {
84534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84535       };
84536     }
84537   }
84538
84539   jresult = (void *)result;
84540   return jresult;
84541 }
84542
84543
84544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
84545   void * jresult ;
84546   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84547   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84548
84549   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84550   {
84551     try {
84552       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
84553     } catch (std::out_of_range& e) {
84554       {
84555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84556       };
84557     } catch (std::exception& e) {
84558       {
84559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84560       };
84561     } catch (Dali::DaliException e) {
84562       {
84563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84564       };
84565     } catch (...) {
84566       {
84567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84568       };
84569     }
84570   }
84571
84572   jresult = (void *)result;
84573   return jresult;
84574 }
84575
84576
84577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
84578   void * jresult ;
84579   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84580   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84581
84582   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84583   {
84584     try {
84585       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
84586     } catch (std::out_of_range& e) {
84587       {
84588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84589       };
84590     } catch (std::exception& e) {
84591       {
84592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84593       };
84594     } catch (Dali::DaliException e) {
84595       {
84596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84597       };
84598     } catch (...) {
84599       {
84600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84601       };
84602     }
84603   }
84604
84605   jresult = (void *)result;
84606   return jresult;
84607 }
84608
84609
84610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
84611   void * jresult ;
84612   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84613   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84614
84615   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84616   {
84617     try {
84618       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
84619     } catch (std::out_of_range& e) {
84620       {
84621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84622       };
84623     } catch (std::exception& e) {
84624       {
84625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84626       };
84627     } catch (Dali::DaliException e) {
84628       {
84629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84630       };
84631     } catch (...) {
84632       {
84633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84634       };
84635     }
84636   }
84637
84638   jresult = (void *)result;
84639   return jresult;
84640 }
84641
84642
84643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
84644   void * jresult ;
84645   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84646   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84647
84648   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84649   {
84650     try {
84651       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
84652     } catch (std::out_of_range& e) {
84653       {
84654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84655       };
84656     } catch (std::exception& e) {
84657       {
84658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84659       };
84660     } catch (Dali::DaliException e) {
84661       {
84662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84663       };
84664     } catch (...) {
84665       {
84666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84667       };
84668     }
84669   }
84670
84671   jresult = (void *)result;
84672   return jresult;
84673 }
84674
84675
84676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
84677   void * jresult ;
84678   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84679   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84680
84681   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84682   {
84683     try {
84684       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
84685     } catch (std::out_of_range& e) {
84686       {
84687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84688       };
84689     } catch (std::exception& e) {
84690       {
84691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84692       };
84693     } catch (Dali::DaliException e) {
84694       {
84695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84696       };
84697     } catch (...) {
84698       {
84699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84700       };
84701     }
84702   }
84703
84704   jresult = (void *)result;
84705   return jresult;
84706 }
84707
84708
84709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
84710   void * jresult ;
84711   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84712   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84713
84714   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84715   {
84716     try {
84717       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
84718     } catch (std::out_of_range& e) {
84719       {
84720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84721       };
84722     } catch (std::exception& e) {
84723       {
84724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84725       };
84726     } catch (Dali::DaliException e) {
84727       {
84728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84729       };
84730     } catch (...) {
84731       {
84732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84733       };
84734     }
84735   }
84736
84737   jresult = (void *)result;
84738   return jresult;
84739 }
84740
84741
84742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
84743   void * jresult ;
84744   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84745   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84746
84747   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84748   {
84749     try {
84750       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
84751     } catch (std::out_of_range& e) {
84752       {
84753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84754       };
84755     } catch (std::exception& e) {
84756       {
84757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84758       };
84759     } catch (Dali::DaliException e) {
84760       {
84761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84762       };
84763     } catch (...) {
84764       {
84765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84766       };
84767     }
84768   }
84769
84770   jresult = (void *)result;
84771   return jresult;
84772 }
84773
84774
84775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
84776   void * jresult ;
84777   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84778   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84779
84780   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84781   {
84782     try {
84783       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
84784     } catch (std::out_of_range& e) {
84785       {
84786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84787       };
84788     } catch (std::exception& e) {
84789       {
84790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84791       };
84792     } catch (Dali::DaliException e) {
84793       {
84794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84795       };
84796     } catch (...) {
84797       {
84798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84799       };
84800     }
84801   }
84802
84803   jresult = (void *)result;
84804   return jresult;
84805 }
84806
84807
84808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
84809   void * jresult ;
84810   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84811   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84812
84813   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84814   {
84815     try {
84816       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
84817     } catch (std::out_of_range& e) {
84818       {
84819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84820       };
84821     } catch (std::exception& e) {
84822       {
84823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84824       };
84825     } catch (Dali::DaliException e) {
84826       {
84827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84828       };
84829     } catch (...) {
84830       {
84831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84832       };
84833     }
84834   }
84835
84836   jresult = (void *)result;
84837   return jresult;
84838 }
84839
84840
84841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
84842   void * jresult ;
84843   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84844   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84845
84846   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84847   {
84848     try {
84849       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
84850     } catch (std::out_of_range& e) {
84851       {
84852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84853       };
84854     } catch (std::exception& e) {
84855       {
84856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84857       };
84858     } catch (Dali::DaliException e) {
84859       {
84860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84861       };
84862     } catch (...) {
84863       {
84864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84865       };
84866     }
84867   }
84868
84869   jresult = (void *)result;
84870   return jresult;
84871 }
84872
84873
84874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
84875   void * jresult ;
84876   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84877   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84878
84879   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84880   {
84881     try {
84882       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
84883     } catch (std::out_of_range& e) {
84884       {
84885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84886       };
84887     } catch (std::exception& e) {
84888       {
84889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84890       };
84891     } catch (Dali::DaliException e) {
84892       {
84893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84894       };
84895     } catch (...) {
84896       {
84897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84898       };
84899     }
84900   }
84901
84902   jresult = (void *)result;
84903   return jresult;
84904 }
84905
84906
84907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
84908   void * jresult ;
84909   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84910   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84911
84912   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84913   {
84914     try {
84915       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
84916     } catch (std::out_of_range& e) {
84917       {
84918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84919       };
84920     } catch (std::exception& e) {
84921       {
84922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84923       };
84924     } catch (Dali::DaliException e) {
84925       {
84926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84927       };
84928     } catch (...) {
84929       {
84930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84931       };
84932     }
84933   }
84934
84935   jresult = (void *)result;
84936   return jresult;
84937 }
84938
84939
84940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
84941   void * jresult ;
84942   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84943   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84944
84945   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84946   {
84947     try {
84948       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
84949     } catch (std::out_of_range& e) {
84950       {
84951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84952       };
84953     } catch (std::exception& e) {
84954       {
84955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84956       };
84957     } catch (Dali::DaliException e) {
84958       {
84959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84960       };
84961     } catch (...) {
84962       {
84963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84964       };
84965     }
84966   }
84967
84968   jresult = (void *)result;
84969   return jresult;
84970 }
84971
84972
84973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
84974   void * jresult ;
84975   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84976   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
84977
84978   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84979   {
84980     try {
84981       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
84982     } catch (std::out_of_range& e) {
84983       {
84984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84985       };
84986     } catch (std::exception& e) {
84987       {
84988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84989       };
84990     } catch (Dali::DaliException e) {
84991       {
84992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84993       };
84994     } catch (...) {
84995       {
84996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84997       };
84998     }
84999   }
85000
85001   jresult = (void *)result;
85002   return jresult;
85003 }
85004
85005
85006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85007   void * jresult ;
85008   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85009   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85010
85011   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85012   {
85013     try {
85014       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85015     } catch (std::out_of_range& e) {
85016       {
85017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85018       };
85019     } catch (std::exception& e) {
85020       {
85021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85022       };
85023     } catch (Dali::DaliException e) {
85024       {
85025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85026       };
85027     } catch (...) {
85028       {
85029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85030       };
85031     }
85032   }
85033
85034   jresult = (void *)result;
85035   return jresult;
85036 }
85037
85038
85039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85040   void * jresult ;
85041   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85042   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85043
85044   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85045   {
85046     try {
85047       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85048     } catch (std::out_of_range& e) {
85049       {
85050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85051       };
85052     } catch (std::exception& e) {
85053       {
85054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (Dali::DaliException e) {
85057       {
85058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85059       };
85060     } catch (...) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85063       };
85064     }
85065   }
85066
85067   jresult = (void *)result;
85068   return jresult;
85069 }
85070
85071
85072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
85073   void * jresult ;
85074   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85075   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
85076
85077   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85078   {
85079     try {
85080       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
85081     } catch (std::out_of_range& e) {
85082       {
85083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85084       };
85085     } catch (std::exception& e) {
85086       {
85087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85088       };
85089     } catch (Dali::DaliException e) {
85090       {
85091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85092       };
85093     } catch (...) {
85094       {
85095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85096       };
85097     }
85098   }
85099
85100   jresult = (void *)result;
85101   return jresult;
85102 }
85103
85104
85105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
85106   void * jresult ;
85107   Dali::Toolkit::StyleManager *result = 0 ;
85108
85109   {
85110     try {
85111       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
85112     } catch (std::out_of_range& e) {
85113       {
85114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85115       };
85116     } catch (std::exception& e) {
85117       {
85118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85119       };
85120     } catch (Dali::DaliException e) {
85121       {
85122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85123       };
85124     } catch (...) {
85125       {
85126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85127       };
85128     }
85129   }
85130
85131   jresult = (void *)result;
85132   return jresult;
85133 }
85134
85135
85136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
85137   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85138
85139   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85140   {
85141     try {
85142       delete arg1;
85143     } catch (std::out_of_range& e) {
85144       {
85145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85146       };
85147     } catch (std::exception& e) {
85148       {
85149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85150       };
85151     } catch (Dali::DaliException e) {
85152       {
85153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85154       };
85155     } catch (...) {
85156       {
85157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85158       };
85159     }
85160   }
85161
85162 }
85163
85164
85165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
85166   void * jresult ;
85167   Dali::Toolkit::StyleManager result;
85168
85169   {
85170     try {
85171       result = Dali::Toolkit::StyleManager::Get();
85172     } catch (std::out_of_range& e) {
85173       {
85174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85175       };
85176     } catch (std::exception& e) {
85177       {
85178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85179       };
85180     } catch (Dali::DaliException e) {
85181       {
85182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85183       };
85184     } catch (...) {
85185       {
85186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85187       };
85188     }
85189   }
85190
85191   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
85192   return jresult;
85193 }
85194
85195
85196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
85197   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85198   std::string *arg2 = 0 ;
85199
85200   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85201   if (!jarg2) {
85202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85203     return ;
85204   }
85205   std::string arg2_str(jarg2);
85206   arg2 = &arg2_str;
85207   {
85208     try {
85209       (arg1)->ApplyTheme((std::string const &)*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   //argout typemap for const std::string&
85231
85232 }
85233
85234
85235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
85236   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85237
85238   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85239   {
85240     try {
85241       (arg1)->ApplyDefaultTheme();
85242     } catch (std::out_of_range& e) {
85243       {
85244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85245       };
85246     } catch (std::exception& e) {
85247       {
85248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85249       };
85250     } catch (Dali::DaliException e) {
85251       {
85252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85253       };
85254     } catch (...) {
85255       {
85256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85257       };
85258     }
85259   }
85260
85261 }
85262
85263
85264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85265   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85266   std::string *arg2 = 0 ;
85267   Dali::Property::Value *arg3 = 0 ;
85268
85269   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85270   if (!jarg2) {
85271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85272     return ;
85273   }
85274   std::string arg2_str(jarg2);
85275   arg2 = &arg2_str;
85276   arg3 = (Dali::Property::Value *)jarg3;
85277   if (!arg3) {
85278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
85279     return ;
85280   }
85281   {
85282     try {
85283       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
85284     } catch (std::out_of_range& e) {
85285       {
85286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85287       };
85288     } catch (std::exception& e) {
85289       {
85290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85291       };
85292     } catch (Dali::DaliException e) {
85293       {
85294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85295       };
85296     } catch (...) {
85297       {
85298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85299       };
85300     }
85301   }
85302
85303
85304   //argout typemap for const std::string&
85305
85306 }
85307
85308
85309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
85310   unsigned int jresult ;
85311   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85312   std::string *arg2 = 0 ;
85313   Dali::Property::Value *arg3 = 0 ;
85314   bool result;
85315
85316   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85317   if (!jarg2) {
85318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85319     return 0;
85320   }
85321   std::string arg2_str(jarg2);
85322   arg2 = &arg2_str;
85323   arg3 = (Dali::Property::Value *)jarg3;
85324   if (!arg3) {
85325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
85326     return 0;
85327   }
85328   {
85329     try {
85330       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
85331     } catch (std::out_of_range& e) {
85332       {
85333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85334       };
85335     } catch (std::exception& e) {
85336       {
85337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85338       };
85339     } catch (Dali::DaliException e) {
85340       {
85341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85342       };
85343     } catch (...) {
85344       {
85345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85346       };
85347     }
85348   }
85349
85350   jresult = result;
85351
85352   //argout typemap for const std::string&
85353
85354   return jresult;
85355 }
85356
85357
85358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
85359   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85360   Dali::Toolkit::Control arg2 ;
85361   std::string *arg3 = 0 ;
85362   std::string *arg4 = 0 ;
85363   Dali::Toolkit::Control *argp2 ;
85364
85365   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85366   argp2 = (Dali::Toolkit::Control *)jarg2;
85367   if (!argp2) {
85368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
85369     return ;
85370   }
85371   arg2 = *argp2;
85372   if (!jarg3) {
85373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85374     return ;
85375   }
85376   std::string arg3_str(jarg3);
85377   arg3 = &arg3_str;
85378   if (!jarg4) {
85379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85380     return ;
85381   }
85382   std::string arg4_str(jarg4);
85383   arg4 = &arg4_str;
85384   {
85385     try {
85386       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
85387     } catch (std::out_of_range& e) {
85388       {
85389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85390       };
85391     } catch (std::exception& e) {
85392       {
85393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85394       };
85395     } catch (Dali::DaliException e) {
85396       {
85397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85398       };
85399     } catch (...) {
85400       {
85401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85402       };
85403     }
85404   }
85405
85406
85407   //argout typemap for const std::string&
85408
85409
85410   //argout typemap for const std::string&
85411
85412 }
85413
85414
85415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
85416   void * jresult ;
85417   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
85418   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
85419
85420   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
85421   {
85422     try {
85423       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
85424     } catch (std::out_of_range& e) {
85425       {
85426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85427       };
85428     } catch (std::exception& e) {
85429       {
85430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85431       };
85432     } catch (Dali::DaliException e) {
85433       {
85434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85435       };
85436     } catch (...) {
85437       {
85438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85439       };
85440     }
85441   }
85442
85443   jresult = (void *)result;
85444   return jresult;
85445 }
85446
85447
85448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
85449   int jresult ;
85450   int result;
85451
85452   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
85453   jresult = (int)result;
85454   return jresult;
85455 }
85456
85457
85458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
85459   int jresult ;
85460   int result;
85461
85462   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
85463   jresult = (int)result;
85464   return jresult;
85465 }
85466
85467
85468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
85469   int jresult ;
85470   int result;
85471
85472   result = (int)Dali::Toolkit::Slider::Property::VALUE;
85473   jresult = (int)result;
85474   return jresult;
85475 }
85476
85477
85478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
85479   int jresult ;
85480   int result;
85481
85482   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
85483   jresult = (int)result;
85484   return jresult;
85485 }
85486
85487
85488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
85489   int jresult ;
85490   int result;
85491
85492   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
85493   jresult = (int)result;
85494   return jresult;
85495 }
85496
85497
85498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
85499   int jresult ;
85500   int result;
85501
85502   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
85503   jresult = (int)result;
85504   return jresult;
85505 }
85506
85507
85508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
85509   int jresult ;
85510   int result;
85511
85512   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
85513   jresult = (int)result;
85514   return jresult;
85515 }
85516
85517
85518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
85519   int jresult ;
85520   int result;
85521
85522   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
85523   jresult = (int)result;
85524   return jresult;
85525 }
85526
85527
85528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
85529   int jresult ;
85530   int result;
85531
85532   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
85533   jresult = (int)result;
85534   return jresult;
85535 }
85536
85537
85538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
85539   int jresult ;
85540   int result;
85541
85542   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
85543   jresult = (int)result;
85544   return jresult;
85545 }
85546
85547
85548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
85549   int jresult ;
85550   int result;
85551
85552   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
85553   jresult = (int)result;
85554   return jresult;
85555 }
85556
85557
85558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
85559   int jresult ;
85560   int result;
85561
85562   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
85563   jresult = (int)result;
85564   return jresult;
85565 }
85566
85567
85568 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
85569   int jresult ;
85570   int result;
85571
85572   result = (int)Dali::Toolkit::Slider::Property::MARKS;
85573   jresult = (int)result;
85574   return jresult;
85575 }
85576
85577
85578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
85579   int jresult ;
85580   int result;
85581
85582   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
85583   jresult = (int)result;
85584   return jresult;
85585 }
85586
85587
85588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
85589   int jresult ;
85590   int result;
85591
85592   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
85593   jresult = (int)result;
85594   return jresult;
85595 }
85596
85597
85598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
85599   void * jresult ;
85600   Dali::Toolkit::Slider::Property *result = 0 ;
85601
85602   {
85603     try {
85604       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
85605     } catch (std::out_of_range& e) {
85606       {
85607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85608       };
85609     } catch (std::exception& e) {
85610       {
85611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85612       };
85613     } catch (Dali::DaliException e) {
85614       {
85615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85616       };
85617     } catch (...) {
85618       {
85619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85620       };
85621     }
85622   }
85623
85624   jresult = (void *)result;
85625   return jresult;
85626 }
85627
85628
85629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
85630   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
85631
85632   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
85633   {
85634     try {
85635       delete arg1;
85636     } catch (std::out_of_range& e) {
85637       {
85638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85639       };
85640     } catch (std::exception& e) {
85641       {
85642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85643       };
85644     } catch (Dali::DaliException e) {
85645       {
85646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85647       };
85648     } catch (...) {
85649       {
85650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85651       };
85652     }
85653   }
85654
85655 }
85656
85657
85658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
85659   void * jresult ;
85660   Dali::Toolkit::Slider result;
85661
85662   {
85663     try {
85664       result = Dali::Toolkit::Slider::New();
85665     } catch (std::out_of_range& e) {
85666       {
85667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85668       };
85669     } catch (std::exception& e) {
85670       {
85671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85672       };
85673     } catch (Dali::DaliException e) {
85674       {
85675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85676       };
85677     } catch (...) {
85678       {
85679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85680       };
85681     }
85682   }
85683
85684   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85685   return jresult;
85686 }
85687
85688
85689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
85690   void * jresult ;
85691   Dali::Toolkit::Slider *result = 0 ;
85692
85693   {
85694     try {
85695       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
85696     } catch (std::out_of_range& e) {
85697       {
85698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85699       };
85700     } catch (std::exception& e) {
85701       {
85702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85703       };
85704     } catch (Dali::DaliException e) {
85705       {
85706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85707       };
85708     } catch (...) {
85709       {
85710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85711       };
85712     }
85713   }
85714
85715   jresult = (void *)result;
85716   return jresult;
85717 }
85718
85719
85720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
85721   void * jresult ;
85722   Dali::Toolkit::Slider *arg1 = 0 ;
85723   Dali::Toolkit::Slider *result = 0 ;
85724
85725   arg1 = (Dali::Toolkit::Slider *)jarg1;
85726   if (!arg1) {
85727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85728     return 0;
85729   }
85730   {
85731     try {
85732       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
85733     } catch (std::out_of_range& e) {
85734       {
85735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85736       };
85737     } catch (std::exception& e) {
85738       {
85739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85740       };
85741     } catch (Dali::DaliException e) {
85742       {
85743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85744       };
85745     } catch (...) {
85746       {
85747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85748       };
85749     }
85750   }
85751
85752   jresult = (void *)result;
85753   return jresult;
85754 }
85755
85756
85757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
85758   void * jresult ;
85759   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85760   Dali::Toolkit::Slider *arg2 = 0 ;
85761   Dali::Toolkit::Slider *result = 0 ;
85762
85763   arg1 = (Dali::Toolkit::Slider *)jarg1;
85764   arg2 = (Dali::Toolkit::Slider *)jarg2;
85765   if (!arg2) {
85766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
85767     return 0;
85768   }
85769   {
85770     try {
85771       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
85772     } catch (std::out_of_range& e) {
85773       {
85774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85775       };
85776     } catch (std::exception& e) {
85777       {
85778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85779       };
85780     } catch (Dali::DaliException e) {
85781       {
85782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85783       };
85784     } catch (...) {
85785       {
85786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85787       };
85788     }
85789   }
85790
85791   jresult = (void *)result;
85792   return jresult;
85793 }
85794
85795
85796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
85797   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85798
85799   arg1 = (Dali::Toolkit::Slider *)jarg1;
85800   {
85801     try {
85802       delete arg1;
85803     } catch (std::out_of_range& e) {
85804       {
85805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85806       };
85807     } catch (std::exception& e) {
85808       {
85809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85810       };
85811     } catch (Dali::DaliException e) {
85812       {
85813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85814       };
85815     } catch (...) {
85816       {
85817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85818       };
85819     }
85820   }
85821
85822 }
85823
85824
85825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
85826   void * jresult ;
85827   Dali::BaseHandle arg1 ;
85828   Dali::BaseHandle *argp1 ;
85829   Dali::Toolkit::Slider result;
85830
85831   argp1 = (Dali::BaseHandle *)jarg1;
85832   if (!argp1) {
85833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85834     return 0;
85835   }
85836   arg1 = *argp1;
85837   {
85838     try {
85839       result = Dali::Toolkit::Slider::DownCast(arg1);
85840     } catch (std::out_of_range& e) {
85841       {
85842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85843       };
85844     } catch (std::exception& e) {
85845       {
85846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85847       };
85848     } catch (Dali::DaliException e) {
85849       {
85850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85851       };
85852     } catch (...) {
85853       {
85854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85855       };
85856     }
85857   }
85858
85859   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
85860   return jresult;
85861 }
85862
85863
85864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
85865   void * jresult ;
85866   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85867   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85868
85869   arg1 = (Dali::Toolkit::Slider *)jarg1;
85870   {
85871     try {
85872       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
85873     } catch (std::out_of_range& e) {
85874       {
85875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85876       };
85877     } catch (std::exception& e) {
85878       {
85879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85880       };
85881     } catch (Dali::DaliException e) {
85882       {
85883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85884       };
85885     } catch (...) {
85886       {
85887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85888       };
85889     }
85890   }
85891
85892   jresult = (void *)result;
85893   return jresult;
85894 }
85895
85896
85897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
85898   void * jresult ;
85899   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85900   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
85901
85902   arg1 = (Dali::Toolkit::Slider *)jarg1;
85903   {
85904     try {
85905       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
85906     } catch (std::out_of_range& e) {
85907       {
85908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85909       };
85910     } catch (std::exception& e) {
85911       {
85912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85913       };
85914     } catch (Dali::DaliException e) {
85915       {
85916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85917       };
85918     } catch (...) {
85919       {
85920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85921       };
85922     }
85923   }
85924
85925   jresult = (void *)result;
85926   return jresult;
85927 }
85928
85929
85930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
85931   void * jresult ;
85932   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
85933   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
85934
85935   arg1 = (Dali::Toolkit::Slider *)jarg1;
85936   {
85937     try {
85938       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
85939     } catch (std::out_of_range& e) {
85940       {
85941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85942       };
85943     } catch (std::exception& e) {
85944       {
85945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85946       };
85947     } catch (Dali::DaliException e) {
85948       {
85949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85950       };
85951     } catch (...) {
85952       {
85953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85954       };
85955     }
85956   }
85957
85958   jresult = (void *)result;
85959   return jresult;
85960 }
85961
85962
85963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
85964   int jresult ;
85965   int result;
85966
85967   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
85968   jresult = (int)result;
85969   return jresult;
85970 }
85971
85972
85973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
85974   int jresult ;
85975   int result;
85976
85977   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
85978   jresult = (int)result;
85979   return jresult;
85980 }
85981
85982
85983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
85984   int jresult ;
85985   int result;
85986
85987   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
85988   jresult = (int)result;
85989   return jresult;
85990 }
85991
85992
85993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
85994   int jresult ;
85995   int result;
85996
85997   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
85998   jresult = (int)result;
85999   return jresult;
86000 }
86001
86002
86003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86004   int result;
86005
86006   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86007
86008   return result;
86009 }
86010
86011
86012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86013   void * jresult ;
86014   Dali::Toolkit::VideoView::Property *result = 0 ;
86015
86016   {
86017     try {
86018       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86019     } catch (std::out_of_range& e) {
86020       {
86021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86022       };
86023     } catch (std::exception& e) {
86024       {
86025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86026       };
86027     } catch (Dali::DaliException e) {
86028       {
86029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86030       };
86031     } catch (...) {
86032       {
86033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86034       };
86035     }
86036   }
86037
86038   jresult = (void *)result;
86039   return jresult;
86040 }
86041
86042
86043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86044   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86045
86046   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86047   {
86048     try {
86049       delete arg1;
86050     } catch (std::out_of_range& e) {
86051       {
86052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86053       };
86054     } catch (std::exception& e) {
86055       {
86056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86057       };
86058     } catch (Dali::DaliException e) {
86059       {
86060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86061       };
86062     } catch (...) {
86063       {
86064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86065       };
86066     }
86067   }
86068
86069 }
86070
86071
86072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
86073   void * jresult ;
86074   Dali::Toolkit::VideoView result;
86075
86076   {
86077     try {
86078       result = Dali::Toolkit::VideoView::New();
86079     } catch (std::out_of_range& e) {
86080       {
86081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86082       };
86083     } catch (std::exception& e) {
86084       {
86085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86086       };
86087     } catch (Dali::DaliException e) {
86088       {
86089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86090       };
86091     } catch (...) {
86092       {
86093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86094       };
86095     }
86096   }
86097
86098   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86099   return jresult;
86100 }
86101
86102
86103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
86104   void * jresult ;
86105   std::string *arg1 = 0 ;
86106   Dali::Toolkit::VideoView result;
86107
86108   if (!jarg1) {
86109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86110     return 0;
86111   }
86112   std::string arg1_str(jarg1);
86113   arg1 = &arg1_str;
86114   {
86115     try {
86116       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
86117     } catch (std::out_of_range& e) {
86118       {
86119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86120       };
86121     } catch (std::exception& e) {
86122       {
86123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86124       };
86125     } catch (Dali::DaliException e) {
86126       {
86127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86128       };
86129     } catch (...) {
86130       {
86131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86132       };
86133     }
86134   }
86135
86136   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86137
86138   //argout typemap for const std::string&
86139
86140   return jresult;
86141 }
86142
86143
86144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
86145   void * jresult ;
86146   Dali::Toolkit::VideoView *result = 0 ;
86147
86148   {
86149     try {
86150       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
86151     } catch (std::out_of_range& e) {
86152       {
86153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86154       };
86155     } catch (std::exception& e) {
86156       {
86157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86158       };
86159     } catch (Dali::DaliException e) {
86160       {
86161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86162       };
86163     } catch (...) {
86164       {
86165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86166       };
86167     }
86168   }
86169
86170   jresult = (void *)result;
86171   return jresult;
86172 }
86173
86174
86175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
86176   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86177
86178   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86179   {
86180     try {
86181       delete arg1;
86182     } catch (std::out_of_range& e) {
86183       {
86184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86185       };
86186     } catch (std::exception& e) {
86187       {
86188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86189       };
86190     } catch (Dali::DaliException e) {
86191       {
86192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86193       };
86194     } catch (...) {
86195       {
86196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86197       };
86198     }
86199   }
86200
86201 }
86202
86203
86204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
86205   void * jresult ;
86206   Dali::Toolkit::VideoView *arg1 = 0 ;
86207   Dali::Toolkit::VideoView *result = 0 ;
86208
86209   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86210   if (!arg1) {
86211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86212     return 0;
86213   }
86214   {
86215     try {
86216       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
86217     } catch (std::out_of_range& e) {
86218       {
86219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86220       };
86221     } catch (std::exception& e) {
86222       {
86223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86224       };
86225     } catch (Dali::DaliException e) {
86226       {
86227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86228       };
86229     } catch (...) {
86230       {
86231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86232       };
86233     }
86234   }
86235
86236   jresult = (void *)result;
86237   return jresult;
86238 }
86239
86240
86241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
86242   void * jresult ;
86243   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86244   Dali::Toolkit::VideoView *arg2 = 0 ;
86245   Dali::Toolkit::VideoView *result = 0 ;
86246
86247   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86248   arg2 = (Dali::Toolkit::VideoView *)jarg2;
86249   if (!arg2) {
86250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
86251     return 0;
86252   }
86253   {
86254     try {
86255       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
86256     } catch (std::out_of_range& e) {
86257       {
86258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86259       };
86260     } catch (std::exception& e) {
86261       {
86262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86263       };
86264     } catch (Dali::DaliException e) {
86265       {
86266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86267       };
86268     } catch (...) {
86269       {
86270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86271       };
86272     }
86273   }
86274
86275   jresult = (void *)result;
86276   return jresult;
86277 }
86278
86279
86280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
86281   void * jresult ;
86282   Dali::BaseHandle arg1 ;
86283   Dali::BaseHandle *argp1 ;
86284   Dali::Toolkit::VideoView result;
86285
86286   argp1 = (Dali::BaseHandle *)jarg1;
86287   if (!argp1) {
86288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86289     return 0;
86290   }
86291   arg1 = *argp1;
86292   {
86293     try {
86294       result = Dali::Toolkit::VideoView::DownCast(arg1);
86295     } catch (std::out_of_range& e) {
86296       {
86297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86298       };
86299     } catch (std::exception& e) {
86300       {
86301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86302       };
86303     } catch (Dali::DaliException e) {
86304       {
86305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86306       };
86307     } catch (...) {
86308       {
86309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86310       };
86311     }
86312   }
86313
86314   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86315   return jresult;
86316 }
86317
86318
86319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
86320   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86321
86322   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86323   {
86324     try {
86325       (arg1)->Play();
86326     } catch (std::out_of_range& e) {
86327       {
86328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86329       };
86330     } catch (std::exception& e) {
86331       {
86332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86333       };
86334     } catch (Dali::DaliException e) {
86335       {
86336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86337       };
86338     } catch (...) {
86339       {
86340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86341       };
86342     }
86343   }
86344
86345 }
86346
86347
86348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
86349   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86350
86351   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86352   {
86353     try {
86354       (arg1)->Pause();
86355     } catch (std::out_of_range& e) {
86356       {
86357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86358       };
86359     } catch (std::exception& e) {
86360       {
86361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86362       };
86363     } catch (Dali::DaliException e) {
86364       {
86365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86366       };
86367     } catch (...) {
86368       {
86369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86370       };
86371     }
86372   }
86373
86374 }
86375
86376
86377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
86378   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86379
86380   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86381   {
86382     try {
86383       (arg1)->Stop();
86384     } catch (std::out_of_range& e) {
86385       {
86386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86387       };
86388     } catch (std::exception& e) {
86389       {
86390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86391       };
86392     } catch (Dali::DaliException e) {
86393       {
86394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86395       };
86396     } catch (...) {
86397       {
86398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86399       };
86400     }
86401   }
86402
86403 }
86404
86405
86406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
86407   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86408   int arg2 ;
86409
86410   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86411   arg2 = (int)jarg2;
86412   {
86413     try {
86414       (arg1)->Forward(arg2);
86415     } catch (std::out_of_range& e) {
86416       {
86417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86418       };
86419     } catch (std::exception& e) {
86420       {
86421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86422       };
86423     } catch (Dali::DaliException e) {
86424       {
86425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86426       };
86427     } catch (...) {
86428       {
86429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86430       };
86431     }
86432   }
86433
86434 }
86435
86436
86437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
86438   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86439   int arg2 ;
86440
86441   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86442   arg2 = (int)jarg2;
86443   {
86444     try {
86445       (arg1)->Backward(arg2);
86446     } catch (std::out_of_range& e) {
86447       {
86448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86449       };
86450     } catch (std::exception& e) {
86451       {
86452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86453       };
86454     } catch (Dali::DaliException e) {
86455       {
86456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86457       };
86458     } catch (...) {
86459       {
86460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86461       };
86462     }
86463   }
86464
86465 }
86466
86467
86468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
86469   void * jresult ;
86470   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
86471   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
86472
86473   arg1 = (Dali::Toolkit::VideoView *)jarg1;
86474   {
86475     try {
86476       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
86477     } catch (std::out_of_range& e) {
86478       {
86479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86480       };
86481     } catch (std::exception& e) {
86482       {
86483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86484       };
86485     } catch (Dali::DaliException e) {
86486       {
86487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86488       };
86489     } catch (...) {
86490       {
86491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86492       };
86493     }
86494   }
86495
86496   jresult = (void *)result;
86497   return jresult;
86498 }
86499
86500
86501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
86502   int jresult ;
86503   int result;
86504
86505   result = (int)Dali::Toolkit::Popup::Property::TITLE;
86506   jresult = (int)result;
86507   return jresult;
86508 }
86509
86510
86511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
86512   int jresult ;
86513   int result;
86514
86515   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
86516   jresult = (int)result;
86517   return jresult;
86518 }
86519
86520
86521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
86522   int jresult ;
86523   int result;
86524
86525   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
86526   jresult = (int)result;
86527   return jresult;
86528 }
86529
86530
86531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
86532   int jresult ;
86533   int result;
86534
86535   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
86536   jresult = (int)result;
86537   return jresult;
86538 }
86539
86540
86541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
86542   int jresult ;
86543   int result;
86544
86545   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
86546   jresult = (int)result;
86547   return jresult;
86548 }
86549
86550
86551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
86552   int jresult ;
86553   int result;
86554
86555   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
86556   jresult = (int)result;
86557   return jresult;
86558 }
86559
86560
86561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
86562   int jresult ;
86563   int result;
86564
86565   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
86566   jresult = (int)result;
86567   return jresult;
86568 }
86569
86570
86571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
86572   int jresult ;
86573   int result;
86574
86575   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
86576   jresult = (int)result;
86577   return jresult;
86578 }
86579
86580
86581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
86582   int jresult ;
86583   int result;
86584
86585   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
86586   jresult = (int)result;
86587   return jresult;
86588 }
86589
86590
86591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
86592   int jresult ;
86593   int result;
86594
86595   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
86596   jresult = (int)result;
86597   return jresult;
86598 }
86599
86600
86601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
86602   int jresult ;
86603   int result;
86604
86605   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
86606   jresult = (int)result;
86607   return jresult;
86608 }
86609
86610
86611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
86612   int jresult ;
86613   int result;
86614
86615   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
86616   jresult = (int)result;
86617   return jresult;
86618 }
86619
86620
86621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
86622   int jresult ;
86623   int result;
86624
86625   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
86626   jresult = (int)result;
86627   return jresult;
86628 }
86629
86630
86631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
86632   int jresult ;
86633   int result;
86634
86635   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
86636   jresult = (int)result;
86637   return jresult;
86638 }
86639
86640
86641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
86642   int jresult ;
86643   int result;
86644
86645   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
86646   jresult = (int)result;
86647   return jresult;
86648 }
86649
86650
86651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
86652   int jresult ;
86653   int result;
86654
86655   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
86656   jresult = (int)result;
86657   return jresult;
86658 }
86659
86660
86661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
86662   int jresult ;
86663   int result;
86664
86665   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
86666   jresult = (int)result;
86667   return jresult;
86668 }
86669
86670
86671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
86672   int jresult ;
86673   int result;
86674
86675   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
86676   jresult = (int)result;
86677   return jresult;
86678 }
86679
86680
86681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
86682   int jresult ;
86683   int result;
86684
86685   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
86686   jresult = (int)result;
86687   return jresult;
86688 }
86689
86690
86691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
86692   int jresult ;
86693   int result;
86694
86695   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
86696   jresult = (int)result;
86697   return jresult;
86698 }
86699
86700
86701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
86702   int jresult ;
86703   int result;
86704
86705   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
86706   jresult = (int)result;
86707   return jresult;
86708 }
86709
86710
86711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
86712   void * jresult ;
86713   Dali::Toolkit::Popup::Property *result = 0 ;
86714
86715   {
86716     try {
86717       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
86718     } catch (std::out_of_range& e) {
86719       {
86720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86721       };
86722     } catch (std::exception& e) {
86723       {
86724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86725       };
86726     } catch (Dali::DaliException e) {
86727       {
86728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86729       };
86730     } catch (...) {
86731       {
86732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86733       };
86734     }
86735   }
86736
86737   jresult = (void *)result;
86738   return jresult;
86739 }
86740
86741
86742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
86743   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
86744
86745   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
86746   {
86747     try {
86748       delete arg1;
86749     } catch (std::out_of_range& e) {
86750       {
86751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86752       };
86753     } catch (std::exception& e) {
86754       {
86755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86756       };
86757     } catch (Dali::DaliException e) {
86758       {
86759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86760       };
86761     } catch (...) {
86762       {
86763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86764       };
86765     }
86766   }
86767
86768 }
86769
86770
86771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
86772   void * jresult ;
86773   Dali::Toolkit::Popup *result = 0 ;
86774
86775   {
86776     try {
86777       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
86778     } catch (std::out_of_range& e) {
86779       {
86780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86781       };
86782     } catch (std::exception& e) {
86783       {
86784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86785       };
86786     } catch (Dali::DaliException e) {
86787       {
86788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86789       };
86790     } catch (...) {
86791       {
86792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86793       };
86794     }
86795   }
86796
86797   jresult = (void *)result;
86798   return jresult;
86799 }
86800
86801
86802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
86803   void * jresult ;
86804   Dali::Toolkit::Popup result;
86805
86806   {
86807     try {
86808       result = Dali::Toolkit::Popup::New();
86809     } catch (std::out_of_range& e) {
86810       {
86811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86812       };
86813     } catch (std::exception& e) {
86814       {
86815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86816       };
86817     } catch (Dali::DaliException e) {
86818       {
86819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86820       };
86821     } catch (...) {
86822       {
86823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86824       };
86825     }
86826   }
86827
86828   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86829   return jresult;
86830 }
86831
86832
86833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
86834   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86835
86836   arg1 = (Dali::Toolkit::Popup *)jarg1;
86837   {
86838     try {
86839       delete arg1;
86840     } catch (std::out_of_range& e) {
86841       {
86842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86843       };
86844     } catch (std::exception& e) {
86845       {
86846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86847       };
86848     } catch (Dali::DaliException e) {
86849       {
86850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86851       };
86852     } catch (...) {
86853       {
86854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86855       };
86856     }
86857   }
86858
86859 }
86860
86861
86862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
86863   void * jresult ;
86864   Dali::Toolkit::Popup *arg1 = 0 ;
86865   Dali::Toolkit::Popup *result = 0 ;
86866
86867   arg1 = (Dali::Toolkit::Popup *)jarg1;
86868   if (!arg1) {
86869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
86870     return 0;
86871   }
86872   {
86873     try {
86874       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
86875     } catch (std::out_of_range& e) {
86876       {
86877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86878       };
86879     } catch (std::exception& e) {
86880       {
86881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86882       };
86883     } catch (Dali::DaliException e) {
86884       {
86885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86886       };
86887     } catch (...) {
86888       {
86889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86890       };
86891     }
86892   }
86893
86894   jresult = (void *)result;
86895   return jresult;
86896 }
86897
86898
86899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
86900   void * jresult ;
86901   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86902   Dali::Toolkit::Popup *arg2 = 0 ;
86903   Dali::Toolkit::Popup *result = 0 ;
86904
86905   arg1 = (Dali::Toolkit::Popup *)jarg1;
86906   arg2 = (Dali::Toolkit::Popup *)jarg2;
86907   if (!arg2) {
86908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
86909     return 0;
86910   }
86911   {
86912     try {
86913       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
86914     } catch (std::out_of_range& e) {
86915       {
86916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86917       };
86918     } catch (std::exception& e) {
86919       {
86920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86921       };
86922     } catch (Dali::DaliException e) {
86923       {
86924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86925       };
86926     } catch (...) {
86927       {
86928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86929       };
86930     }
86931   }
86932
86933   jresult = (void *)result;
86934   return jresult;
86935 }
86936
86937
86938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
86939   void * jresult ;
86940   Dali::BaseHandle arg1 ;
86941   Dali::BaseHandle *argp1 ;
86942   Dali::Toolkit::Popup result;
86943
86944   argp1 = (Dali::BaseHandle *)jarg1;
86945   if (!argp1) {
86946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86947     return 0;
86948   }
86949   arg1 = *argp1;
86950   {
86951     try {
86952       result = Dali::Toolkit::Popup::DownCast(arg1);
86953     } catch (std::out_of_range& e) {
86954       {
86955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86956       };
86957     } catch (std::exception& e) {
86958       {
86959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86960       };
86961     } catch (Dali::DaliException e) {
86962       {
86963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86964       };
86965     } catch (...) {
86966       {
86967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86968       };
86969     }
86970   }
86971
86972   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
86973   return jresult;
86974 }
86975
86976
86977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
86978   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86979   Dali::Actor arg2 ;
86980   Dali::Actor *argp2 ;
86981
86982   arg1 = (Dali::Toolkit::Popup *)jarg1;
86983   argp2 = (Dali::Actor *)jarg2;
86984   if (!argp2) {
86985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86986     return ;
86987   }
86988   arg2 = *argp2;
86989   {
86990     try {
86991       (arg1)->SetTitle(arg2);
86992     } catch (std::out_of_range& e) {
86993       {
86994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86995       };
86996     } catch (std::exception& e) {
86997       {
86998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86999       };
87000     } catch (Dali::DaliException e) {
87001       {
87002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87003       };
87004     } catch (...) {
87005       {
87006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87007       };
87008     }
87009   }
87010
87011 }
87012
87013
87014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87015   void * jresult ;
87016   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87017   Dali::Actor result;
87018
87019   arg1 = (Dali::Toolkit::Popup *)jarg1;
87020   {
87021     try {
87022       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87023     } catch (std::out_of_range& e) {
87024       {
87025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87026       };
87027     } catch (std::exception& e) {
87028       {
87029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87030       };
87031     } catch (Dali::DaliException e) {
87032       {
87033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87034       };
87035     } catch (...) {
87036       {
87037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87038       };
87039     }
87040   }
87041
87042   jresult = new Dali::Actor((const Dali::Actor &)result);
87043   return jresult;
87044 }
87045
87046
87047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87048   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87049   Dali::Actor arg2 ;
87050   Dali::Actor *argp2 ;
87051
87052   arg1 = (Dali::Toolkit::Popup *)jarg1;
87053   argp2 = (Dali::Actor *)jarg2;
87054   if (!argp2) {
87055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87056     return ;
87057   }
87058   arg2 = *argp2;
87059   {
87060     try {
87061       (arg1)->SetContent(arg2);
87062     } catch (std::out_of_range& e) {
87063       {
87064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87065       };
87066     } catch (std::exception& e) {
87067       {
87068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87069       };
87070     } catch (Dali::DaliException e) {
87071       {
87072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87073       };
87074     } catch (...) {
87075       {
87076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87077       };
87078     }
87079   }
87080
87081 }
87082
87083
87084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
87085   void * jresult ;
87086   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87087   Dali::Actor result;
87088
87089   arg1 = (Dali::Toolkit::Popup *)jarg1;
87090   {
87091     try {
87092       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
87093     } catch (std::out_of_range& e) {
87094       {
87095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87096       };
87097     } catch (std::exception& e) {
87098       {
87099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87100       };
87101     } catch (Dali::DaliException e) {
87102       {
87103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87104       };
87105     } catch (...) {
87106       {
87107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87108       };
87109     }
87110   }
87111
87112   jresult = new Dali::Actor((const Dali::Actor &)result);
87113   return jresult;
87114 }
87115
87116
87117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
87118   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87119   Dali::Actor arg2 ;
87120   Dali::Actor *argp2 ;
87121
87122   arg1 = (Dali::Toolkit::Popup *)jarg1;
87123   argp2 = (Dali::Actor *)jarg2;
87124   if (!argp2) {
87125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87126     return ;
87127   }
87128   arg2 = *argp2;
87129   {
87130     try {
87131       (arg1)->SetFooter(arg2);
87132     } catch (std::out_of_range& e) {
87133       {
87134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87135       };
87136     } catch (std::exception& e) {
87137       {
87138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87139       };
87140     } catch (Dali::DaliException e) {
87141       {
87142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87143       };
87144     } catch (...) {
87145       {
87146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87147       };
87148     }
87149   }
87150
87151 }
87152
87153
87154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
87155   void * jresult ;
87156   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87157   Dali::Actor result;
87158
87159   arg1 = (Dali::Toolkit::Popup *)jarg1;
87160   {
87161     try {
87162       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
87163     } catch (std::out_of_range& e) {
87164       {
87165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87166       };
87167     } catch (std::exception& e) {
87168       {
87169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87170       };
87171     } catch (Dali::DaliException e) {
87172       {
87173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87174       };
87175     } catch (...) {
87176       {
87177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87178       };
87179     }
87180   }
87181
87182   jresult = new Dali::Actor((const Dali::Actor &)result);
87183   return jresult;
87184 }
87185
87186
87187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
87188   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87189   Dali::Toolkit::Popup::DisplayState arg2 ;
87190
87191   arg1 = (Dali::Toolkit::Popup *)jarg1;
87192   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
87193   {
87194     try {
87195       (arg1)->SetDisplayState(arg2);
87196     } catch (std::out_of_range& e) {
87197       {
87198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87199       };
87200     } catch (std::exception& e) {
87201       {
87202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87203       };
87204     } catch (Dali::DaliException e) {
87205       {
87206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87207       };
87208     } catch (...) {
87209       {
87210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87211       };
87212     }
87213   }
87214
87215 }
87216
87217
87218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
87219   int jresult ;
87220   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87221   Dali::Toolkit::Popup::DisplayState result;
87222
87223   arg1 = (Dali::Toolkit::Popup *)jarg1;
87224   {
87225     try {
87226       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
87227     } catch (std::out_of_range& e) {
87228       {
87229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87230       };
87231     } catch (std::exception& e) {
87232       {
87233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87234       };
87235     } catch (Dali::DaliException e) {
87236       {
87237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87238       };
87239     } catch (...) {
87240       {
87241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87242       };
87243     }
87244   }
87245
87246   jresult = (int)result;
87247   return jresult;
87248 }
87249
87250
87251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
87252   void * jresult ;
87253   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87254   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
87255
87256   arg1 = (Dali::Toolkit::Popup *)jarg1;
87257   {
87258     try {
87259       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
87260     } catch (std::out_of_range& e) {
87261       {
87262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87263       };
87264     } catch (std::exception& e) {
87265       {
87266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87267       };
87268     } catch (Dali::DaliException e) {
87269       {
87270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87271       };
87272     } catch (...) {
87273       {
87274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87275       };
87276     }
87277   }
87278
87279   jresult = (void *)result;
87280   return jresult;
87281 }
87282
87283
87284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
87285   void * jresult ;
87286   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87287   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87288
87289   arg1 = (Dali::Toolkit::Popup *)jarg1;
87290   {
87291     try {
87292       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
87293     } catch (std::out_of_range& e) {
87294       {
87295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87296       };
87297     } catch (std::exception& e) {
87298       {
87299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87300       };
87301     } catch (Dali::DaliException e) {
87302       {
87303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87304       };
87305     } catch (...) {
87306       {
87307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87308       };
87309     }
87310   }
87311
87312   jresult = (void *)result;
87313   return jresult;
87314 }
87315
87316
87317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
87318   void * jresult ;
87319   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87320   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87321
87322   arg1 = (Dali::Toolkit::Popup *)jarg1;
87323   {
87324     try {
87325       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
87326     } catch (std::out_of_range& e) {
87327       {
87328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87329       };
87330     } catch (std::exception& e) {
87331       {
87332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87333       };
87334     } catch (Dali::DaliException e) {
87335       {
87336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87337       };
87338     } catch (...) {
87339       {
87340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87341       };
87342     }
87343   }
87344
87345   jresult = (void *)result;
87346   return jresult;
87347 }
87348
87349
87350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
87351   void * jresult ;
87352   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87353   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87354
87355   arg1 = (Dali::Toolkit::Popup *)jarg1;
87356   {
87357     try {
87358       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
87359     } catch (std::out_of_range& e) {
87360       {
87361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87362       };
87363     } catch (std::exception& e) {
87364       {
87365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87366       };
87367     } catch (Dali::DaliException e) {
87368       {
87369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87370       };
87371     } catch (...) {
87372       {
87373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87374       };
87375     }
87376   }
87377
87378   jresult = (void *)result;
87379   return jresult;
87380 }
87381
87382
87383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
87384   void * jresult ;
87385   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87386   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
87387
87388   arg1 = (Dali::Toolkit::Popup *)jarg1;
87389   {
87390     try {
87391       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
87392     } catch (std::out_of_range& e) {
87393       {
87394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87395       };
87396     } catch (std::exception& e) {
87397       {
87398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87399       };
87400     } catch (Dali::DaliException e) {
87401       {
87402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87403       };
87404     } catch (...) {
87405       {
87406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87407       };
87408     }
87409   }
87410
87411   jresult = (void *)result;
87412   return jresult;
87413 }
87414
87415
87416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
87417   int jresult ;
87418   int result;
87419
87420   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
87421   jresult = (int)result;
87422   return jresult;
87423 }
87424
87425
87426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
87427   int jresult ;
87428   int result;
87429
87430   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
87431   jresult = (int)result;
87432   return jresult;
87433 }
87434
87435
87436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
87437   int jresult ;
87438   int result;
87439
87440   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
87441   jresult = (int)result;
87442   return jresult;
87443 }
87444
87445
87446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
87447   int jresult ;
87448   int result;
87449
87450   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
87451   jresult = (int)result;
87452   return jresult;
87453 }
87454
87455
87456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
87457   int jresult ;
87458   int result;
87459
87460   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
87461   jresult = (int)result;
87462   return jresult;
87463 }
87464
87465
87466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
87467   int jresult ;
87468   int result;
87469
87470   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
87471   jresult = (int)result;
87472   return jresult;
87473 }
87474
87475
87476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
87477   int jresult ;
87478   int result;
87479
87480   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
87481   jresult = (int)result;
87482   return jresult;
87483 }
87484
87485
87486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
87487   int jresult ;
87488   int result;
87489
87490   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
87491   jresult = (int)result;
87492   return jresult;
87493 }
87494
87495
87496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
87497   int jresult ;
87498   int result;
87499
87500   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
87501   jresult = (int)result;
87502   return jresult;
87503 }
87504
87505
87506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
87507   void * jresult ;
87508   Dali::Toolkit::ProgressBar::Property *result = 0 ;
87509
87510   {
87511     try {
87512       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
87513     } catch (std::out_of_range& e) {
87514       {
87515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87516       };
87517     } catch (std::exception& e) {
87518       {
87519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87520       };
87521     } catch (Dali::DaliException e) {
87522       {
87523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87524       };
87525     } catch (...) {
87526       {
87527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87528       };
87529     }
87530   }
87531
87532   jresult = (void *)result;
87533   return jresult;
87534 }
87535
87536
87537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
87538   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
87539
87540   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
87541   {
87542     try {
87543       delete arg1;
87544     } catch (std::out_of_range& e) {
87545       {
87546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87547       };
87548     } catch (std::exception& e) {
87549       {
87550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87551       };
87552     } catch (Dali::DaliException e) {
87553       {
87554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87555       };
87556     } catch (...) {
87557       {
87558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87559       };
87560     }
87561   }
87562
87563 }
87564
87565
87566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
87567   void * jresult ;
87568   Dali::Toolkit::ProgressBar result;
87569
87570   {
87571     try {
87572       result = Dali::Toolkit::ProgressBar::New();
87573     } catch (std::out_of_range& e) {
87574       {
87575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87576       };
87577     } catch (std::exception& e) {
87578       {
87579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87580       };
87581     } catch (Dali::DaliException e) {
87582       {
87583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87584       };
87585     } catch (...) {
87586       {
87587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87588       };
87589     }
87590   }
87591
87592   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87593   return jresult;
87594 }
87595
87596
87597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
87598   void * jresult ;
87599   Dali::Toolkit::ProgressBar *result = 0 ;
87600
87601   {
87602     try {
87603       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
87604     } catch (std::out_of_range& e) {
87605       {
87606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87607       };
87608     } catch (std::exception& e) {
87609       {
87610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87611       };
87612     } catch (Dali::DaliException e) {
87613       {
87614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87615       };
87616     } catch (...) {
87617       {
87618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87619       };
87620     }
87621   }
87622
87623   jresult = (void *)result;
87624   return jresult;
87625 }
87626
87627
87628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
87629   void * jresult ;
87630   Dali::Toolkit::ProgressBar *arg1 = 0 ;
87631   Dali::Toolkit::ProgressBar *result = 0 ;
87632
87633   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87634   if (!arg1) {
87635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87636     return 0;
87637   }
87638   {
87639     try {
87640       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
87641     } catch (std::out_of_range& e) {
87642       {
87643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87644       };
87645     } catch (std::exception& e) {
87646       {
87647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87648       };
87649     } catch (Dali::DaliException e) {
87650       {
87651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87652       };
87653     } catch (...) {
87654       {
87655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87656       };
87657     }
87658   }
87659
87660   jresult = (void *)result;
87661   return jresult;
87662 }
87663
87664
87665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
87666   void * jresult ;
87667   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87668   Dali::Toolkit::ProgressBar *arg2 = 0 ;
87669   Dali::Toolkit::ProgressBar *result = 0 ;
87670
87671   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87672   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
87673   if (!arg2) {
87674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
87675     return 0;
87676   }
87677   {
87678     try {
87679       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
87680     } catch (std::out_of_range& e) {
87681       {
87682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87683       };
87684     } catch (std::exception& e) {
87685       {
87686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87687       };
87688     } catch (Dali::DaliException e) {
87689       {
87690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87691       };
87692     } catch (...) {
87693       {
87694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87695       };
87696     }
87697   }
87698
87699   jresult = (void *)result;
87700   return jresult;
87701 }
87702
87703
87704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
87705   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87706
87707   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87708   {
87709     try {
87710       delete arg1;
87711     } catch (std::out_of_range& e) {
87712       {
87713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87714       };
87715     } catch (std::exception& e) {
87716       {
87717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87718       };
87719     } catch (Dali::DaliException e) {
87720       {
87721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87722       };
87723     } catch (...) {
87724       {
87725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87726       };
87727     }
87728   }
87729
87730 }
87731
87732
87733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
87734   void * jresult ;
87735   Dali::BaseHandle arg1 ;
87736   Dali::BaseHandle *argp1 ;
87737   Dali::Toolkit::ProgressBar result;
87738
87739   argp1 = (Dali::BaseHandle *)jarg1;
87740   if (!argp1) {
87741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87742     return 0;
87743   }
87744   arg1 = *argp1;
87745   {
87746     try {
87747       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
87748     } catch (std::out_of_range& e) {
87749       {
87750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87751       };
87752     } catch (std::exception& e) {
87753       {
87754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87755       };
87756     } catch (Dali::DaliException e) {
87757       {
87758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87759       };
87760     } catch (...) {
87761       {
87762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87763       };
87764     }
87765   }
87766
87767   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
87768   return jresult;
87769 }
87770
87771
87772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
87773   void * jresult ;
87774   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
87775   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
87776
87777   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
87778   {
87779     try {
87780       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87781     } catch (std::out_of_range& e) {
87782       {
87783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87784       };
87785     } catch (std::exception& e) {
87786       {
87787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87788       };
87789     } catch (Dali::DaliException e) {
87790       {
87791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87792       };
87793     } catch (...) {
87794       {
87795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87796       };
87797     }
87798   }
87799
87800   jresult = (void *)result;
87801   return jresult;
87802 }
87803
87804
87805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
87806   void * jresult ;
87807   Dali::Toolkit::GaussianBlurView *result = 0 ;
87808
87809   {
87810     try {
87811       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
87812     } catch (std::out_of_range& e) {
87813       {
87814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87815       };
87816     } catch (std::exception& e) {
87817       {
87818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87819       };
87820     } catch (Dali::DaliException e) {
87821       {
87822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87823       };
87824     } catch (...) {
87825       {
87826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87827       };
87828     }
87829   }
87830
87831   jresult = (void *)result;
87832   return jresult;
87833 }
87834
87835
87836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
87837   void * jresult ;
87838   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
87839   Dali::Toolkit::GaussianBlurView *result = 0 ;
87840
87841   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87842   if (!arg1) {
87843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
87844     return 0;
87845   }
87846   {
87847     try {
87848       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
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 = (void *)result;
87869   return jresult;
87870 }
87871
87872
87873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
87874   void * jresult ;
87875   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87876   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
87877   Dali::Toolkit::GaussianBlurView *result = 0 ;
87878
87879   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87880   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
87881   if (!arg2) {
87882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
87883     return 0;
87884   }
87885   {
87886     try {
87887       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
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 = (void *)result;
87908   return jresult;
87909 }
87910
87911
87912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
87913   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87914
87915   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87916   {
87917     try {
87918       delete arg1;
87919     } catch (std::out_of_range& e) {
87920       {
87921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87922       };
87923     } catch (std::exception& e) {
87924       {
87925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87926       };
87927     } catch (Dali::DaliException e) {
87928       {
87929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87930       };
87931     } catch (...) {
87932       {
87933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87934       };
87935     }
87936   }
87937
87938 }
87939
87940
87941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
87942   void * jresult ;
87943   Dali::BaseHandle arg1 ;
87944   Dali::BaseHandle *argp1 ;
87945   Dali::Toolkit::GaussianBlurView result;
87946
87947   argp1 = (Dali::BaseHandle *)jarg1;
87948   if (!argp1) {
87949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87950     return 0;
87951   }
87952   arg1 = *argp1;
87953   {
87954     try {
87955       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
87956     } catch (std::out_of_range& e) {
87957       {
87958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87959       };
87960     } catch (std::exception& e) {
87961       {
87962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87963       };
87964     } catch (Dali::DaliException e) {
87965       {
87966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87967       };
87968     } catch (...) {
87969       {
87970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87971       };
87972     }
87973   }
87974
87975   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
87976   return jresult;
87977 }
87978
87979
87980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
87981   void * jresult ;
87982   Dali::Toolkit::GaussianBlurView result;
87983
87984   {
87985     try {
87986       result = Dali::Toolkit::GaussianBlurView::New();
87987     } catch (std::out_of_range& e) {
87988       {
87989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87990       };
87991     } catch (std::exception& e) {
87992       {
87993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87994       };
87995     } catch (Dali::DaliException e) {
87996       {
87997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87998       };
87999     } catch (...) {
88000       {
88001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88002       };
88003     }
88004   }
88005
88006   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88007   return jresult;
88008 }
88009
88010
88011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88012   void * jresult ;
88013   unsigned int arg1 ;
88014   float arg2 ;
88015   Dali::Pixel::Format arg3 ;
88016   float arg4 ;
88017   float arg5 ;
88018   bool arg6 ;
88019   Dali::Toolkit::GaussianBlurView result;
88020
88021   arg1 = (unsigned int)jarg1;
88022   arg2 = (float)jarg2;
88023   arg3 = (Dali::Pixel::Format)jarg3;
88024   arg4 = (float)jarg4;
88025   arg5 = (float)jarg5;
88026   arg6 = jarg6 ? true : false;
88027   {
88028     try {
88029       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88030     } catch (std::out_of_range& e) {
88031       {
88032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88033       };
88034     } catch (std::exception& e) {
88035       {
88036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88037       };
88038     } catch (Dali::DaliException e) {
88039       {
88040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88041       };
88042     } catch (...) {
88043       {
88044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88045       };
88046     }
88047   }
88048
88049   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88050   return jresult;
88051 }
88052
88053
88054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88055   void * jresult ;
88056   unsigned int arg1 ;
88057   float arg2 ;
88058   Dali::Pixel::Format arg3 ;
88059   float arg4 ;
88060   float arg5 ;
88061   Dali::Toolkit::GaussianBlurView result;
88062
88063   arg1 = (unsigned int)jarg1;
88064   arg2 = (float)jarg2;
88065   arg3 = (Dali::Pixel::Format)jarg3;
88066   arg4 = (float)jarg4;
88067   arg5 = (float)jarg5;
88068   {
88069     try {
88070       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
88071     } catch (std::out_of_range& e) {
88072       {
88073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88074       };
88075     } catch (std::exception& e) {
88076       {
88077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88078       };
88079     } catch (Dali::DaliException e) {
88080       {
88081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88082       };
88083     } catch (...) {
88084       {
88085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88086       };
88087     }
88088   }
88089
88090   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88091   return jresult;
88092 }
88093
88094
88095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
88096   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88097   Dali::Actor arg2 ;
88098   Dali::Actor *argp2 ;
88099
88100   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88101   argp2 = (Dali::Actor *)jarg2;
88102   if (!argp2) {
88103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88104     return ;
88105   }
88106   arg2 = *argp2;
88107   {
88108     try {
88109       (arg1)->Add(arg2);
88110     } catch (std::out_of_range& e) {
88111       {
88112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88113       };
88114     } catch (std::exception& e) {
88115       {
88116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88117       };
88118     } catch (Dali::DaliException e) {
88119       {
88120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88121       };
88122     } catch (...) {
88123       {
88124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88125       };
88126     }
88127   }
88128
88129 }
88130
88131
88132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
88133   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88134   Dali::Actor arg2 ;
88135   Dali::Actor *argp2 ;
88136
88137   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88138   argp2 = (Dali::Actor *)jarg2;
88139   if (!argp2) {
88140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88141     return ;
88142   }
88143   arg2 = *argp2;
88144   {
88145     try {
88146       (arg1)->Remove(arg2);
88147     } catch (std::out_of_range& e) {
88148       {
88149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88150       };
88151     } catch (std::exception& e) {
88152       {
88153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88154       };
88155     } catch (Dali::DaliException e) {
88156       {
88157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88158       };
88159     } catch (...) {
88160       {
88161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88162       };
88163     }
88164   }
88165
88166 }
88167
88168
88169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
88170   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88171
88172   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88173   {
88174     try {
88175       (arg1)->Activate();
88176     } catch (std::out_of_range& e) {
88177       {
88178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88179       };
88180     } catch (std::exception& e) {
88181       {
88182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88183       };
88184     } catch (Dali::DaliException e) {
88185       {
88186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88187       };
88188     } catch (...) {
88189       {
88190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88191       };
88192     }
88193   }
88194
88195 }
88196
88197
88198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
88199   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88200
88201   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88202   {
88203     try {
88204       (arg1)->ActivateOnce();
88205     } catch (std::out_of_range& e) {
88206       {
88207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88208       };
88209     } catch (std::exception& e) {
88210       {
88211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88212       };
88213     } catch (Dali::DaliException e) {
88214       {
88215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88216       };
88217     } catch (...) {
88218       {
88219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88220       };
88221     }
88222   }
88223
88224 }
88225
88226
88227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
88228   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88229
88230   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88231   {
88232     try {
88233       (arg1)->Deactivate();
88234     } catch (std::out_of_range& e) {
88235       {
88236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88237       };
88238     } catch (std::exception& e) {
88239       {
88240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88241       };
88242     } catch (Dali::DaliException e) {
88243       {
88244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88245       };
88246     } catch (...) {
88247       {
88248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88249       };
88250     }
88251   }
88252
88253 }
88254
88255
88256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
88257   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88258   Dali::Texture arg2 ;
88259   Dali::FrameBuffer arg3 ;
88260   Dali::Texture *argp2 ;
88261   Dali::FrameBuffer *argp3 ;
88262
88263   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88264   argp2 = (Dali::Texture *)jarg2;
88265   if (!argp2) {
88266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
88267     return ;
88268   }
88269   arg2 = *argp2;
88270   argp3 = (Dali::FrameBuffer *)jarg3;
88271   if (!argp3) {
88272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
88273     return ;
88274   }
88275   arg3 = *argp3;
88276   {
88277     try {
88278       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
88279     } catch (std::out_of_range& e) {
88280       {
88281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88282       };
88283     } catch (std::exception& e) {
88284       {
88285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88286       };
88287     } catch (Dali::DaliException e) {
88288       {
88289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88290       };
88291     } catch (...) {
88292       {
88293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88294       };
88295     }
88296   }
88297
88298 }
88299
88300
88301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
88302   int jresult ;
88303   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88304   Dali::Property::Index result;
88305
88306   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88307   {
88308     try {
88309       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
88310     } catch (std::out_of_range& e) {
88311       {
88312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88313       };
88314     } catch (std::exception& e) {
88315       {
88316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88317       };
88318     } catch (Dali::DaliException e) {
88319       {
88320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88321       };
88322     } catch (...) {
88323       {
88324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88325       };
88326     }
88327   }
88328
88329   jresult = result;
88330   return jresult;
88331 }
88332
88333
88334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
88335   void * jresult ;
88336   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88337   Dali::FrameBuffer result;
88338
88339   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88340   {
88341     try {
88342       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
88343     } catch (std::out_of_range& e) {
88344       {
88345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88346       };
88347     } catch (std::exception& e) {
88348       {
88349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88350       };
88351     } catch (Dali::DaliException e) {
88352       {
88353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88354       };
88355     } catch (...) {
88356       {
88357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88358       };
88359     }
88360   }
88361
88362   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
88363   return jresult;
88364 }
88365
88366
88367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
88368   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88369   Dali::Vector4 *arg2 = 0 ;
88370
88371   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88372   arg2 = (Dali::Vector4 *)jarg2;
88373   if (!arg2) {
88374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
88375     return ;
88376   }
88377   {
88378     try {
88379       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
88380     } catch (std::out_of_range& e) {
88381       {
88382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88383       };
88384     } catch (std::exception& e) {
88385       {
88386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88387       };
88388     } catch (Dali::DaliException e) {
88389       {
88390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88391       };
88392     } catch (...) {
88393       {
88394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88395       };
88396     }
88397   }
88398
88399 }
88400
88401
88402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
88403   void * jresult ;
88404   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88405   Dali::Vector4 result;
88406
88407   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88408   {
88409     try {
88410       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
88411     } catch (std::out_of_range& e) {
88412       {
88413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88414       };
88415     } catch (std::exception& e) {
88416       {
88417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88418       };
88419     } catch (Dali::DaliException e) {
88420       {
88421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88422       };
88423     } catch (...) {
88424       {
88425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88426       };
88427     }
88428   }
88429
88430   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
88431   return jresult;
88432 }
88433
88434
88435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
88436   void * jresult ;
88437   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88438   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
88439
88440   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88441   {
88442     try {
88443       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
88444     } catch (std::out_of_range& e) {
88445       {
88446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88447       };
88448     } catch (std::exception& e) {
88449       {
88450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88451       };
88452     } catch (Dali::DaliException e) {
88453       {
88454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88455       };
88456     } catch (...) {
88457       {
88458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88459       };
88460     }
88461   }
88462
88463   jresult = (void *)result;
88464   return jresult;
88465 }
88466
88467
88468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
88469   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88470
88471   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88472   {
88473     try {
88474       delete arg1;
88475     } catch (std::out_of_range& e) {
88476       {
88477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88478       };
88479     } catch (std::exception& e) {
88480       {
88481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88482       };
88483     } catch (Dali::DaliException e) {
88484       {
88485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88486       };
88487     } catch (...) {
88488       {
88489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88490       };
88491     }
88492   }
88493
88494 }
88495
88496
88497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
88498   unsigned int jresult ;
88499   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88500   unsigned int result;
88501
88502   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88503   {
88504     try {
88505       result = (unsigned int)(arg1)->GetNumberOfPages();
88506     } catch (std::out_of_range& e) {
88507       {
88508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88509       };
88510     } catch (std::exception& e) {
88511       {
88512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88513       };
88514     } catch (Dali::DaliException e) {
88515       {
88516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88517       };
88518     } catch (...) {
88519       {
88520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88521       };
88522     }
88523   }
88524
88525   jresult = result;
88526   return jresult;
88527 }
88528
88529
88530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
88531   void * jresult ;
88532   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
88533   unsigned int arg2 ;
88534   Dali::Texture result;
88535
88536   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88537   arg2 = (unsigned int)jarg2;
88538   {
88539     try {
88540       result = (arg1)->NewPage(arg2);
88541     } catch (std::out_of_range& e) {
88542       {
88543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88544       };
88545     } catch (std::exception& e) {
88546       {
88547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88548       };
88549     } catch (Dali::DaliException e) {
88550       {
88551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88552       };
88553     } catch (...) {
88554       {
88555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88556       };
88557     }
88558   }
88559
88560   jresult = new Dali::Texture((const Dali::Texture &)result);
88561   return jresult;
88562 }
88563
88564
88565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
88566   int jresult ;
88567   int result;
88568
88569   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
88570   jresult = (int)result;
88571   return jresult;
88572 }
88573
88574
88575 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
88576   int jresult ;
88577   int result;
88578
88579   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
88580   jresult = (int)result;
88581   return jresult;
88582 }
88583
88584
88585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
88586   int jresult ;
88587   int result;
88588
88589   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
88590   jresult = (int)result;
88591   return jresult;
88592 }
88593
88594
88595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
88596   void * jresult ;
88597   Dali::Toolkit::PageTurnView::Property *result = 0 ;
88598
88599   {
88600     try {
88601       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
88602     } catch (std::out_of_range& e) {
88603       {
88604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88605       };
88606     } catch (std::exception& e) {
88607       {
88608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88609       };
88610     } catch (Dali::DaliException e) {
88611       {
88612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88613       };
88614     } catch (...) {
88615       {
88616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88617       };
88618     }
88619   }
88620
88621   jresult = (void *)result;
88622   return jresult;
88623 }
88624
88625
88626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
88627   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
88628
88629   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
88630   {
88631     try {
88632       delete arg1;
88633     } catch (std::out_of_range& e) {
88634       {
88635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88636       };
88637     } catch (std::exception& e) {
88638       {
88639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88640       };
88641     } catch (Dali::DaliException e) {
88642       {
88643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88644       };
88645     } catch (...) {
88646       {
88647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88648       };
88649     }
88650   }
88651
88652 }
88653
88654
88655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
88656   void * jresult ;
88657   Dali::Toolkit::PageTurnView *result = 0 ;
88658
88659   {
88660     try {
88661       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
88662     } catch (std::out_of_range& e) {
88663       {
88664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88665       };
88666     } catch (std::exception& e) {
88667       {
88668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88669       };
88670     } catch (Dali::DaliException e) {
88671       {
88672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88673       };
88674     } catch (...) {
88675       {
88676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88677       };
88678     }
88679   }
88680
88681   jresult = (void *)result;
88682   return jresult;
88683 }
88684
88685
88686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
88687   void * jresult ;
88688   Dali::Toolkit::PageTurnView *arg1 = 0 ;
88689   Dali::Toolkit::PageTurnView *result = 0 ;
88690
88691   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88692   if (!arg1) {
88693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88694     return 0;
88695   }
88696   {
88697     try {
88698       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
88699     } catch (std::out_of_range& e) {
88700       {
88701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88702       };
88703     } catch (std::exception& e) {
88704       {
88705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88706       };
88707     } catch (Dali::DaliException e) {
88708       {
88709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88710       };
88711     } catch (...) {
88712       {
88713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88714       };
88715     }
88716   }
88717
88718   jresult = (void *)result;
88719   return jresult;
88720 }
88721
88722
88723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
88724   void * jresult ;
88725   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88726   Dali::Toolkit::PageTurnView *arg2 = 0 ;
88727   Dali::Toolkit::PageTurnView *result = 0 ;
88728
88729   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88730   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
88731   if (!arg2) {
88732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
88733     return 0;
88734   }
88735   {
88736     try {
88737       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
88738     } catch (std::out_of_range& e) {
88739       {
88740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88741       };
88742     } catch (std::exception& e) {
88743       {
88744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88745       };
88746     } catch (Dali::DaliException e) {
88747       {
88748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88749       };
88750     } catch (...) {
88751       {
88752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88753       };
88754     }
88755   }
88756
88757   jresult = (void *)result;
88758   return jresult;
88759 }
88760
88761
88762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
88763   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88764
88765   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88766   {
88767     try {
88768       delete arg1;
88769     } catch (std::out_of_range& e) {
88770       {
88771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88772       };
88773     } catch (std::exception& e) {
88774       {
88775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88776       };
88777     } catch (Dali::DaliException e) {
88778       {
88779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88780       };
88781     } catch (...) {
88782       {
88783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88784       };
88785     }
88786   }
88787
88788 }
88789
88790
88791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
88792   void * jresult ;
88793   Dali::BaseHandle arg1 ;
88794   Dali::BaseHandle *argp1 ;
88795   Dali::Toolkit::PageTurnView 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::PageTurnView::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::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
88826   return jresult;
88827 }
88828
88829
88830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
88831   void * jresult ;
88832   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88833   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88834
88835   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88836   {
88837     try {
88838       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
88839     } catch (std::out_of_range& e) {
88840       {
88841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88842       };
88843     } catch (std::exception& e) {
88844       {
88845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88846       };
88847     } catch (Dali::DaliException e) {
88848       {
88849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88850       };
88851     } catch (...) {
88852       {
88853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88854       };
88855     }
88856   }
88857
88858   jresult = (void *)result;
88859   return jresult;
88860 }
88861
88862
88863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
88864   void * jresult ;
88865   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88866   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
88867
88868   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88869   {
88870     try {
88871       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
88872     } catch (std::out_of_range& e) {
88873       {
88874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88875       };
88876     } catch (std::exception& e) {
88877       {
88878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88879       };
88880     } catch (Dali::DaliException e) {
88881       {
88882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88883       };
88884     } catch (...) {
88885       {
88886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88887       };
88888     }
88889   }
88890
88891   jresult = (void *)result;
88892   return jresult;
88893 }
88894
88895
88896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
88897   void * jresult ;
88898   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88899   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
88900
88901   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88902   {
88903     try {
88904       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
88905     } catch (std::out_of_range& e) {
88906       {
88907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88908       };
88909     } catch (std::exception& e) {
88910       {
88911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88912       };
88913     } catch (Dali::DaliException e) {
88914       {
88915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88916       };
88917     } catch (...) {
88918       {
88919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88920       };
88921     }
88922   }
88923
88924   jresult = (void *)result;
88925   return jresult;
88926 }
88927
88928
88929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
88930   void * jresult ;
88931   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
88932   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
88933
88934   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
88935   {
88936     try {
88937       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
88938     } catch (std::out_of_range& e) {
88939       {
88940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88941       };
88942     } catch (std::exception& e) {
88943       {
88944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88945       };
88946     } catch (Dali::DaliException e) {
88947       {
88948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88949       };
88950     } catch (...) {
88951       {
88952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88953       };
88954     }
88955   }
88956
88957   jresult = (void *)result;
88958   return jresult;
88959 }
88960
88961
88962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
88963   void * jresult ;
88964   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
88965
88966   {
88967     try {
88968       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
88969     } catch (std::out_of_range& e) {
88970       {
88971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88972       };
88973     } catch (std::exception& e) {
88974       {
88975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88976       };
88977     } catch (Dali::DaliException e) {
88978       {
88979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88980       };
88981     } catch (...) {
88982       {
88983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88984       };
88985     }
88986   }
88987
88988   jresult = (void *)result;
88989   return jresult;
88990 }
88991
88992
88993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
88994   void * jresult ;
88995   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
88996   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
88997
88998   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
88999   if (!arg1) {
89000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89001     return 0;
89002   }
89003   {
89004     try {
89005       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89006     } catch (std::out_of_range& e) {
89007       {
89008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89009       };
89010     } catch (std::exception& e) {
89011       {
89012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89013       };
89014     } catch (Dali::DaliException e) {
89015       {
89016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89017       };
89018     } catch (...) {
89019       {
89020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89021       };
89022     }
89023   }
89024
89025   jresult = (void *)result;
89026   return jresult;
89027 }
89028
89029
89030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89031   void * jresult ;
89032   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89033   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89034   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89035
89036   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89037   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89038   if (!arg2) {
89039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89040     return 0;
89041   }
89042   {
89043     try {
89044       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89045     } catch (std::out_of_range& e) {
89046       {
89047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89048       };
89049     } catch (std::exception& e) {
89050       {
89051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89052       };
89053     } catch (Dali::DaliException e) {
89054       {
89055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89056       };
89057     } catch (...) {
89058       {
89059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89060       };
89061     }
89062   }
89063
89064   jresult = (void *)result;
89065   return jresult;
89066 }
89067
89068
89069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
89070   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89071
89072   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89073   {
89074     try {
89075       delete arg1;
89076     } catch (std::out_of_range& e) {
89077       {
89078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89079       };
89080     } catch (std::exception& e) {
89081       {
89082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89083       };
89084     } catch (Dali::DaliException e) {
89085       {
89086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89087       };
89088     } catch (...) {
89089       {
89090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89091       };
89092     }
89093   }
89094
89095 }
89096
89097
89098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
89099   void * jresult ;
89100   Dali::Toolkit::PageFactory *arg1 = 0 ;
89101   Dali::Vector2 *arg2 = 0 ;
89102   Dali::Toolkit::PageTurnLandscapeView result;
89103
89104   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89105   if (!arg1) {
89106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89107     return 0;
89108   }
89109   arg2 = (Dali::Vector2 *)jarg2;
89110   if (!arg2) {
89111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89112     return 0;
89113   }
89114   {
89115     try {
89116       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
89117     } catch (std::out_of_range& e) {
89118       {
89119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89120       };
89121     } catch (std::exception& e) {
89122       {
89123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89124       };
89125     } catch (Dali::DaliException e) {
89126       {
89127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89128       };
89129     } catch (...) {
89130       {
89131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89132       };
89133     }
89134   }
89135
89136   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89137   return jresult;
89138 }
89139
89140
89141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
89142   void * jresult ;
89143   Dali::BaseHandle arg1 ;
89144   Dali::BaseHandle *argp1 ;
89145   Dali::Toolkit::PageTurnLandscapeView result;
89146
89147   argp1 = (Dali::BaseHandle *)jarg1;
89148   if (!argp1) {
89149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89150     return 0;
89151   }
89152   arg1 = *argp1;
89153   {
89154     try {
89155       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
89156     } catch (std::out_of_range& e) {
89157       {
89158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89159       };
89160     } catch (std::exception& e) {
89161       {
89162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89163       };
89164     } catch (Dali::DaliException e) {
89165       {
89166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89167       };
89168     } catch (...) {
89169       {
89170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89171       };
89172     }
89173   }
89174
89175   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
89176   return jresult;
89177 }
89178
89179
89180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
89181   void * jresult ;
89182   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89183
89184   {
89185     try {
89186       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
89187     } catch (std::out_of_range& e) {
89188       {
89189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89190       };
89191     } catch (std::exception& e) {
89192       {
89193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89194       };
89195     } catch (Dali::DaliException e) {
89196       {
89197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89198       };
89199     } catch (...) {
89200       {
89201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89202       };
89203     }
89204   }
89205
89206   jresult = (void *)result;
89207   return jresult;
89208 }
89209
89210
89211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
89212   void * jresult ;
89213   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
89214   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89215
89216   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89217   if (!arg1) {
89218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89219     return 0;
89220   }
89221   {
89222     try {
89223       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
89224     } catch (std::out_of_range& e) {
89225       {
89226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89227       };
89228     } catch (std::exception& e) {
89229       {
89230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89231       };
89232     } catch (Dali::DaliException e) {
89233       {
89234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89235       };
89236     } catch (...) {
89237       {
89238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89239       };
89240     }
89241   }
89242
89243   jresult = (void *)result;
89244   return jresult;
89245 }
89246
89247
89248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
89249   void * jresult ;
89250   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89251   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
89252   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
89253
89254   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89255   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
89256   if (!arg2) {
89257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
89258     return 0;
89259   }
89260   {
89261     try {
89262       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
89263     } catch (std::out_of_range& e) {
89264       {
89265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89266       };
89267     } catch (std::exception& e) {
89268       {
89269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89270       };
89271     } catch (Dali::DaliException e) {
89272       {
89273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89274       };
89275     } catch (...) {
89276       {
89277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89278       };
89279     }
89280   }
89281
89282   jresult = (void *)result;
89283   return jresult;
89284 }
89285
89286
89287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
89288   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
89289
89290   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
89291   {
89292     try {
89293       delete arg1;
89294     } catch (std::out_of_range& e) {
89295       {
89296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89297       };
89298     } catch (std::exception& e) {
89299       {
89300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89301       };
89302     } catch (Dali::DaliException e) {
89303       {
89304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89305       };
89306     } catch (...) {
89307       {
89308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89309       };
89310     }
89311   }
89312
89313 }
89314
89315
89316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
89317   void * jresult ;
89318   Dali::Toolkit::PageFactory *arg1 = 0 ;
89319   Dali::Vector2 *arg2 = 0 ;
89320   Dali::Toolkit::PageTurnPortraitView result;
89321
89322   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89323   if (!arg1) {
89324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
89325     return 0;
89326   }
89327   arg2 = (Dali::Vector2 *)jarg2;
89328   if (!arg2) {
89329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
89330     return 0;
89331   }
89332   {
89333     try {
89334       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
89335     } catch (std::out_of_range& e) {
89336       {
89337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89338       };
89339     } catch (std::exception& e) {
89340       {
89341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89342       };
89343     } catch (Dali::DaliException e) {
89344       {
89345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89346       };
89347     } catch (...) {
89348       {
89349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89350       };
89351     }
89352   }
89353
89354   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89355   return jresult;
89356 }
89357
89358
89359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
89360   void * jresult ;
89361   Dali::BaseHandle arg1 ;
89362   Dali::BaseHandle *argp1 ;
89363   Dali::Toolkit::PageTurnPortraitView result;
89364
89365   argp1 = (Dali::BaseHandle *)jarg1;
89366   if (!argp1) {
89367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89368     return 0;
89369   }
89370   arg1 = *argp1;
89371   {
89372     try {
89373       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
89374     } catch (std::out_of_range& e) {
89375       {
89376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89377       };
89378     } catch (std::exception& e) {
89379       {
89380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89381       };
89382     } catch (Dali::DaliException e) {
89383       {
89384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89385       };
89386     } catch (...) {
89387       {
89388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89389       };
89390     }
89391   }
89392
89393   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
89394   return jresult;
89395 }
89396
89397
89398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
89399   int jresult ;
89400   int result;
89401
89402   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
89403   jresult = (int)result;
89404   return jresult;
89405 }
89406
89407
89408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
89409   int jresult ;
89410   int result;
89411
89412   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
89413   jresult = (int)result;
89414   return jresult;
89415 }
89416
89417
89418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
89419   int jresult ;
89420   int result;
89421
89422   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
89423   jresult = (int)result;
89424   return jresult;
89425 }
89426
89427
89428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
89429   void * jresult ;
89430   Dali::Toolkit::ToggleButton::Property *result = 0 ;
89431
89432   {
89433     try {
89434       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
89435     } catch (std::out_of_range& e) {
89436       {
89437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89438       };
89439     } catch (std::exception& e) {
89440       {
89441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89442       };
89443     } catch (Dali::DaliException e) {
89444       {
89445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89446       };
89447     } catch (...) {
89448       {
89449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89450       };
89451     }
89452   }
89453
89454   jresult = (void *)result;
89455   return jresult;
89456 }
89457
89458
89459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
89460   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
89461
89462   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
89463   {
89464     try {
89465       delete arg1;
89466     } catch (std::out_of_range& e) {
89467       {
89468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89469       };
89470     } catch (std::exception& e) {
89471       {
89472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89473       };
89474     } catch (Dali::DaliException e) {
89475       {
89476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89477       };
89478     } catch (...) {
89479       {
89480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89481       };
89482     }
89483   }
89484
89485 }
89486
89487
89488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
89489   void * jresult ;
89490   Dali::Toolkit::ToggleButton *result = 0 ;
89491
89492   {
89493     try {
89494       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
89495     } catch (std::out_of_range& e) {
89496       {
89497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89498       };
89499     } catch (std::exception& e) {
89500       {
89501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89502       };
89503     } catch (Dali::DaliException e) {
89504       {
89505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89506       };
89507     } catch (...) {
89508       {
89509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89510       };
89511     }
89512   }
89513
89514   jresult = (void *)result;
89515   return jresult;
89516 }
89517
89518
89519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
89520   void * jresult ;
89521   Dali::Toolkit::ToggleButton *arg1 = 0 ;
89522   Dali::Toolkit::ToggleButton *result = 0 ;
89523
89524   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89525   if (!arg1) {
89526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89527     return 0;
89528   }
89529   {
89530     try {
89531       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
89532     } catch (std::out_of_range& e) {
89533       {
89534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89535       };
89536     } catch (std::exception& e) {
89537       {
89538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89539       };
89540     } catch (Dali::DaliException e) {
89541       {
89542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89543       };
89544     } catch (...) {
89545       {
89546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89547       };
89548     }
89549   }
89550
89551   jresult = (void *)result;
89552   return jresult;
89553 }
89554
89555
89556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
89557   void * jresult ;
89558   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89559   Dali::Toolkit::ToggleButton *arg2 = 0 ;
89560   Dali::Toolkit::ToggleButton *result = 0 ;
89561
89562   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89563   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
89564   if (!arg2) {
89565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
89566     return 0;
89567   }
89568   {
89569     try {
89570       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
89571     } catch (std::out_of_range& e) {
89572       {
89573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89574       };
89575     } catch (std::exception& e) {
89576       {
89577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89578       };
89579     } catch (Dali::DaliException e) {
89580       {
89581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89582       };
89583     } catch (...) {
89584       {
89585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89586       };
89587     }
89588   }
89589
89590   jresult = (void *)result;
89591   return jresult;
89592 }
89593
89594
89595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
89596   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
89597
89598   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
89599   {
89600     try {
89601       delete arg1;
89602     } catch (std::out_of_range& e) {
89603       {
89604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89605       };
89606     } catch (std::exception& e) {
89607       {
89608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89609       };
89610     } catch (Dali::DaliException e) {
89611       {
89612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89613       };
89614     } catch (...) {
89615       {
89616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89617       };
89618     }
89619   }
89620
89621 }
89622
89623
89624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
89625   void * jresult ;
89626   Dali::Toolkit::ToggleButton result;
89627
89628   {
89629     try {
89630       result = Dali::Toolkit::ToggleButton::New();
89631     } catch (std::out_of_range& e) {
89632       {
89633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89634       };
89635     } catch (std::exception& e) {
89636       {
89637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89638       };
89639     } catch (Dali::DaliException e) {
89640       {
89641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89642       };
89643     } catch (...) {
89644       {
89645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89646       };
89647     }
89648   }
89649
89650   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89651   return jresult;
89652 }
89653
89654
89655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
89656   void * jresult ;
89657   Dali::BaseHandle arg1 ;
89658   Dali::BaseHandle *argp1 ;
89659   Dali::Toolkit::ToggleButton result;
89660
89661   argp1 = (Dali::BaseHandle *)jarg1;
89662   if (!argp1) {
89663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89664     return 0;
89665   }
89666   arg1 = *argp1;
89667   {
89668     try {
89669       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
89670     } catch (std::out_of_range& e) {
89671       {
89672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89673       };
89674     } catch (std::exception& e) {
89675       {
89676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89677       };
89678     } catch (Dali::DaliException e) {
89679       {
89680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89681       };
89682     } catch (...) {
89683       {
89684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89685       };
89686     }
89687   }
89688
89689   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
89690   return jresult;
89691 }
89692
89693
89694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
89695   void * jresult ;
89696   Dali::Toolkit::Visual::Base *result = 0 ;
89697
89698   {
89699     try {
89700       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
89701     } catch (std::out_of_range& e) {
89702       {
89703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89704       };
89705     } catch (std::exception& e) {
89706       {
89707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89708       };
89709     } catch (Dali::DaliException e) {
89710       {
89711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89712       };
89713     } catch (...) {
89714       {
89715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89716       };
89717     }
89718   }
89719
89720   jresult = (void *)result;
89721   return jresult;
89722 }
89723
89724
89725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
89726   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89727
89728   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89729   {
89730     try {
89731       delete arg1;
89732     } catch (std::out_of_range& e) {
89733       {
89734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89735       };
89736     } catch (std::exception& e) {
89737       {
89738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89739       };
89740     } catch (Dali::DaliException e) {
89741       {
89742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89743       };
89744     } catch (...) {
89745       {
89746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89747       };
89748     }
89749   }
89750
89751 }
89752
89753
89754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
89755   void * jresult ;
89756   Dali::Toolkit::Visual::Base *arg1 = 0 ;
89757   Dali::Toolkit::Visual::Base *result = 0 ;
89758
89759   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89760   if (!arg1) {
89761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89762     return 0;
89763   }
89764   {
89765     try {
89766       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
89767     } catch (std::out_of_range& e) {
89768       {
89769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89770       };
89771     } catch (std::exception& e) {
89772       {
89773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89774       };
89775     } catch (Dali::DaliException e) {
89776       {
89777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89778       };
89779     } catch (...) {
89780       {
89781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89782       };
89783     }
89784   }
89785
89786   jresult = (void *)result;
89787   return jresult;
89788 }
89789
89790
89791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
89792   void * jresult ;
89793   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89794   Dali::Toolkit::Visual::Base *arg2 = 0 ;
89795   Dali::Toolkit::Visual::Base *result = 0 ;
89796
89797   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89798   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
89799   if (!arg2) {
89800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
89801     return 0;
89802   }
89803   {
89804     try {
89805       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
89806     } catch (std::out_of_range& e) {
89807       {
89808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89809       };
89810     } catch (std::exception& e) {
89811       {
89812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89813       };
89814     } catch (Dali::DaliException e) {
89815       {
89816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89817       };
89818     } catch (...) {
89819       {
89820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89821       };
89822     }
89823   }
89824
89825   jresult = (void *)result;
89826   return jresult;
89827 }
89828
89829
89830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
89831   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89832   std::string *arg2 = 0 ;
89833
89834   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89835   if (!jarg2) {
89836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89837     return ;
89838   }
89839   std::string arg2_str(jarg2);
89840   arg2 = &arg2_str;
89841   {
89842     try {
89843       (arg1)->SetName((std::string const &)*arg2);
89844     } catch (std::out_of_range& e) {
89845       {
89846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89847       };
89848     } catch (std::exception& e) {
89849       {
89850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89851       };
89852     } catch (Dali::DaliException e) {
89853       {
89854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89855       };
89856     } catch (...) {
89857       {
89858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89859       };
89860     }
89861   }
89862
89863
89864   //argout typemap for const std::string&
89865
89866 }
89867
89868
89869 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
89870   char * jresult ;
89871   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89872   std::string *result = 0 ;
89873
89874   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89875   {
89876     try {
89877       result = (std::string *) &(arg1)->GetName();
89878     } catch (std::out_of_range& e) {
89879       {
89880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89881       };
89882     } catch (std::exception& e) {
89883       {
89884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89885       };
89886     } catch (Dali::DaliException e) {
89887       {
89888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89889       };
89890     } catch (...) {
89891       {
89892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89893       };
89894     }
89895   }
89896
89897   jresult = SWIG_csharp_string_callback(result->c_str());
89898   return jresult;
89899 }
89900
89901
89902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
89903   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89904   Dali::Property::Map *arg2 = 0 ;
89905   Dali::Size arg3 ;
89906   Dali::Size *argp3 ;
89907
89908   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89909   arg2 = (Dali::Property::Map *)jarg2;
89910   if (!arg2) {
89911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
89912     return ;
89913   }
89914   argp3 = (Dali::Size *)jarg3;
89915   if (!argp3) {
89916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
89917     return ;
89918   }
89919   arg3 = *argp3;
89920   {
89921     try {
89922       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
89923     } catch (std::out_of_range& e) {
89924       {
89925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89926       };
89927     } catch (std::exception& e) {
89928       {
89929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89930       };
89931     } catch (Dali::DaliException e) {
89932       {
89933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89934       };
89935     } catch (...) {
89936       {
89937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89938       };
89939     }
89940   }
89941
89942 }
89943
89944
89945 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
89946   float jresult ;
89947   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89948   float arg2 ;
89949   float result;
89950
89951   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89952   arg2 = (float)jarg2;
89953   {
89954     try {
89955       result = (float)(arg1)->GetHeightForWidth(arg2);
89956     } catch (std::out_of_range& e) {
89957       {
89958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89959       };
89960     } catch (std::exception& e) {
89961       {
89962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89963       };
89964     } catch (Dali::DaliException e) {
89965       {
89966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89967       };
89968     } catch (...) {
89969       {
89970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89971       };
89972     }
89973   }
89974
89975   jresult = result;
89976   return jresult;
89977 }
89978
89979
89980 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
89981   float jresult ;
89982   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
89983   float arg2 ;
89984   float result;
89985
89986   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
89987   arg2 = (float)jarg2;
89988   {
89989     try {
89990       result = (float)(arg1)->GetWidthForHeight(arg2);
89991     } catch (std::out_of_range& e) {
89992       {
89993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89994       };
89995     } catch (std::exception& e) {
89996       {
89997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89998       };
89999     } catch (Dali::DaliException e) {
90000       {
90001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90002       };
90003     } catch (...) {
90004       {
90005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90006       };
90007     }
90008   }
90009
90010   jresult = result;
90011   return jresult;
90012 }
90013
90014
90015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90016   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90017   Dali::Vector2 *arg2 = 0 ;
90018
90019   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90020   arg2 = (Dali::Vector2 *)jarg2;
90021   if (!arg2) {
90022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90023     return ;
90024   }
90025   {
90026     try {
90027       (arg1)->GetNaturalSize(*arg2);
90028     } catch (std::out_of_range& e) {
90029       {
90030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90031       };
90032     } catch (std::exception& e) {
90033       {
90034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90035       };
90036     } catch (Dali::DaliException e) {
90037       {
90038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90039       };
90040     } catch (...) {
90041       {
90042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90043       };
90044     }
90045   }
90046
90047 }
90048
90049
90050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90051   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90052   float arg2 ;
90053
90054   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90055   arg2 = (int)jarg2;
90056   {
90057     try {
90058       (arg1)->SetDepthIndex(arg2);
90059     } catch (std::out_of_range& e) {
90060       {
90061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90062       };
90063     } catch (std::exception& e) {
90064       {
90065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90066       };
90067     } catch (Dali::DaliException e) {
90068       {
90069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90070       };
90071     } catch (...) {
90072       {
90073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90074       };
90075     }
90076   }
90077
90078 }
90079
90080
90081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
90082   int jresult ;
90083   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90084   int result;
90085
90086   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90087   {
90088     try {
90089       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
90090     } catch (std::out_of_range& e) {
90091       {
90092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90093       };
90094     } catch (std::exception& e) {
90095       {
90096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90097       };
90098     } catch (Dali::DaliException e) {
90099       {
90100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90101       };
90102     } catch (...) {
90103       {
90104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90105       };
90106     }
90107   }
90108
90109   jresult = result;
90110   return jresult;
90111 }
90112
90113
90114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
90115   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90116   Dali::Property::Map *arg2 = 0 ;
90117
90118   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90119   arg2 = (Dali::Property::Map *)jarg2;
90120   if (!arg2) {
90121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
90122     return ;
90123   }
90124   {
90125     try {
90126       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
90127     } catch (std::out_of_range& e) {
90128       {
90129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90130       };
90131     } catch (std::exception& e) {
90132       {
90133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90134       };
90135     } catch (Dali::DaliException e) {
90136       {
90137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90138       };
90139     } catch (...) {
90140       {
90141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90142       };
90143     }
90144   }
90145
90146 }
90147
90148
90149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
90150   void * jresult ;
90151   Dali::Toolkit::VisualFactory result;
90152
90153   {
90154     try {
90155       result = Dali::Toolkit::VisualFactory::Get();
90156     } catch (std::out_of_range& e) {
90157       {
90158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90159       };
90160     } catch (std::exception& e) {
90161       {
90162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90163       };
90164     } catch (Dali::DaliException e) {
90165       {
90166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90167       };
90168     } catch (...) {
90169       {
90170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90171       };
90172     }
90173   }
90174
90175   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
90176   return jresult;
90177 }
90178
90179
90180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
90181   void * jresult ;
90182   Dali::Toolkit::VisualFactory *result = 0 ;
90183
90184   {
90185     try {
90186       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
90187     } catch (std::out_of_range& e) {
90188       {
90189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90190       };
90191     } catch (std::exception& e) {
90192       {
90193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90194       };
90195     } catch (Dali::DaliException e) {
90196       {
90197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90198       };
90199     } catch (...) {
90200       {
90201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90202       };
90203     }
90204   }
90205
90206   jresult = (void *)result;
90207   return jresult;
90208 }
90209
90210
90211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
90212   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90213
90214   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90215   {
90216     try {
90217       delete arg1;
90218     } catch (std::out_of_range& e) {
90219       {
90220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90221       };
90222     } catch (std::exception& e) {
90223       {
90224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90225       };
90226     } catch (Dali::DaliException e) {
90227       {
90228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90229       };
90230     } catch (...) {
90231       {
90232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90233       };
90234     }
90235   }
90236
90237 }
90238
90239
90240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
90241   void * jresult ;
90242   Dali::Toolkit::VisualFactory *arg1 = 0 ;
90243   Dali::Toolkit::VisualFactory *result = 0 ;
90244
90245   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90246   if (!arg1) {
90247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90248     return 0;
90249   }
90250   {
90251     try {
90252       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
90253     } catch (std::out_of_range& e) {
90254       {
90255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90256       };
90257     } catch (std::exception& e) {
90258       {
90259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90260       };
90261     } catch (Dali::DaliException e) {
90262       {
90263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90264       };
90265     } catch (...) {
90266       {
90267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90268       };
90269     }
90270   }
90271
90272   jresult = (void *)result;
90273   return jresult;
90274 }
90275
90276
90277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
90278   void * jresult ;
90279   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90280   Dali::Toolkit::VisualFactory *arg2 = 0 ;
90281   Dali::Toolkit::VisualFactory *result = 0 ;
90282
90283   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90284   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
90285   if (!arg2) {
90286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
90287     return 0;
90288   }
90289   {
90290     try {
90291       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
90292     } catch (std::out_of_range& e) {
90293       {
90294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90295       };
90296     } catch (std::exception& e) {
90297       {
90298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90299       };
90300     } catch (Dali::DaliException e) {
90301       {
90302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90303       };
90304     } catch (...) {
90305       {
90306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90307       };
90308     }
90309   }
90310
90311   jresult = (void *)result;
90312   return jresult;
90313 }
90314
90315
90316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
90317   void * jresult ;
90318   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90319   Dali::Property::Map *arg2 = 0 ;
90320   Dali::Toolkit::Visual::Base result;
90321
90322   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90323   arg2 = (Dali::Property::Map *)jarg2;
90324   if (!arg2) {
90325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90326     return 0;
90327   }
90328   {
90329     try {
90330       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
90331     } catch (std::out_of_range& e) {
90332       {
90333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90334       };
90335     } catch (std::exception& e) {
90336       {
90337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90338       };
90339     } catch (Dali::DaliException e) {
90340       {
90341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90342       };
90343     } catch (...) {
90344       {
90345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90346       };
90347     }
90348   }
90349
90350   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90351   return jresult;
90352 }
90353
90354
90355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
90356   void * jresult ;
90357   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90358   Dali::Image *arg2 = 0 ;
90359   Dali::Toolkit::Visual::Base result;
90360
90361   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90362   arg2 = (Dali::Image *)jarg2;
90363   if (!arg2) {
90364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
90365     return 0;
90366   }
90367   {
90368     try {
90369       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
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 = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90390   return jresult;
90391 }
90392
90393
90394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
90395   void * jresult ;
90396   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
90397   std::string *arg2 = 0 ;
90398   Dali::ImageDimensions arg3 ;
90399   Dali::ImageDimensions *argp3 ;
90400   Dali::Toolkit::Visual::Base result;
90401
90402   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
90403   if (!jarg2) {
90404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90405     return 0;
90406   }
90407   std::string arg2_str(jarg2);
90408   arg2 = &arg2_str;
90409   argp3 = (Dali::ImageDimensions *)jarg3;
90410   if (!argp3) {
90411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90412     return 0;
90413   }
90414   arg3 = *argp3;
90415   {
90416     try {
90417       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
90418     } catch (std::out_of_range& e) {
90419       {
90420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90421       };
90422     } catch (std::exception& e) {
90423       {
90424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90425       };
90426     } catch (Dali::DaliException e) {
90427       {
90428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90429       };
90430     } catch (...) {
90431       {
90432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90433       };
90434     }
90435   }
90436
90437   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
90438
90439   //argout typemap for const std::string&
90440
90441   return jresult;
90442 }
90443
90444
90445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
90446   void * jresult ;
90447   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90448
90449   {
90450     try {
90451       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
90452     } catch (std::out_of_range& e) {
90453       {
90454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90455       };
90456     } catch (std::exception& e) {
90457       {
90458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90459       };
90460     } catch (Dali::DaliException e) {
90461       {
90462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90463       };
90464     } catch (...) {
90465       {
90466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90467       };
90468     }
90469   }
90470
90471   jresult = (void *)result;
90472   return jresult;
90473 }
90474
90475
90476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
90477   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90478
90479   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90480   {
90481     try {
90482       delete arg1;
90483     } catch (std::out_of_range& e) {
90484       {
90485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90486       };
90487     } catch (std::exception& e) {
90488       {
90489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90490       };
90491     } catch (Dali::DaliException e) {
90492       {
90493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90494       };
90495     } catch (...) {
90496       {
90497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90498       };
90499     }
90500   }
90501
90502 }
90503
90504
90505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
90506   void * jresult ;
90507   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
90508   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90509
90510   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90511   if (!arg1) {
90512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90513     return 0;
90514   }
90515   {
90516     try {
90517       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
90518     } catch (std::out_of_range& e) {
90519       {
90520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90521       };
90522     } catch (std::exception& e) {
90523       {
90524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90525       };
90526     } catch (Dali::DaliException e) {
90527       {
90528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90529       };
90530     } catch (...) {
90531       {
90532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90533       };
90534     }
90535   }
90536
90537   jresult = (void *)result;
90538   return jresult;
90539 }
90540
90541
90542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
90543   void * jresult ;
90544   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90545   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
90546   Dali::Toolkit::AsyncImageLoader *result = 0 ;
90547
90548   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90549   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
90550   if (!arg2) {
90551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
90552     return 0;
90553   }
90554   {
90555     try {
90556       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
90557     } catch (std::out_of_range& e) {
90558       {
90559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90560       };
90561     } catch (std::exception& e) {
90562       {
90563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90564       };
90565     } catch (Dali::DaliException e) {
90566       {
90567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90568       };
90569     } catch (...) {
90570       {
90571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90572       };
90573     }
90574   }
90575
90576   jresult = (void *)result;
90577   return jresult;
90578 }
90579
90580
90581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
90582   void * jresult ;
90583   Dali::Toolkit::AsyncImageLoader result;
90584
90585   {
90586     try {
90587       result = Dali::Toolkit::AsyncImageLoader::New();
90588     } catch (std::out_of_range& e) {
90589       {
90590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90591       };
90592     } catch (std::exception& e) {
90593       {
90594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90595       };
90596     } catch (Dali::DaliException e) {
90597       {
90598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90599       };
90600     } catch (...) {
90601       {
90602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90603       };
90604     }
90605   }
90606
90607   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90608   return jresult;
90609 }
90610
90611
90612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
90613   void * jresult ;
90614   Dali::BaseHandle arg1 ;
90615   Dali::BaseHandle *argp1 ;
90616   Dali::Toolkit::AsyncImageLoader result;
90617
90618   argp1 = (Dali::BaseHandle *)jarg1;
90619   if (!argp1) {
90620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90621     return 0;
90622   }
90623   arg1 = *argp1;
90624   {
90625     try {
90626       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
90627     } catch (std::out_of_range& e) {
90628       {
90629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90630       };
90631     } catch (std::exception& e) {
90632       {
90633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90634       };
90635     } catch (Dali::DaliException e) {
90636       {
90637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90638       };
90639     } catch (...) {
90640       {
90641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90642       };
90643     }
90644   }
90645
90646   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
90647   return jresult;
90648 }
90649
90650
90651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
90652   unsigned int jresult ;
90653   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90654   std::string *arg2 = 0 ;
90655   uint32_t result;
90656
90657   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90658   if (!jarg2) {
90659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90660     return 0;
90661   }
90662   std::string arg2_str(jarg2);
90663   arg2 = &arg2_str;
90664   {
90665     try {
90666       result = (arg1)->Load((std::string const &)*arg2);
90667     } catch (std::out_of_range& e) {
90668       {
90669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90670       };
90671     } catch (std::exception& e) {
90672       {
90673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90674       };
90675     } catch (Dali::DaliException e) {
90676       {
90677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90678       };
90679     } catch (...) {
90680       {
90681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90682       };
90683     }
90684   }
90685
90686   jresult = result;
90687
90688   //argout typemap for const std::string&
90689
90690   return jresult;
90691 }
90692
90693
90694 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
90695   unsigned int jresult ;
90696   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90697   std::string *arg2 = 0 ;
90698   Dali::ImageDimensions arg3 ;
90699   Dali::ImageDimensions *argp3 ;
90700   uint32_t result;
90701
90702   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90703   if (!jarg2) {
90704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90705     return 0;
90706   }
90707   std::string arg2_str(jarg2);
90708   arg2 = &arg2_str;
90709   argp3 = (Dali::ImageDimensions *)jarg3;
90710   if (!argp3) {
90711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90712     return 0;
90713   }
90714   arg3 = *argp3;
90715   {
90716     try {
90717       result = (arg1)->Load((std::string const &)*arg2,arg3);
90718     } catch (std::out_of_range& e) {
90719       {
90720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90721       };
90722     } catch (std::exception& e) {
90723       {
90724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90725       };
90726     } catch (Dali::DaliException e) {
90727       {
90728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90729       };
90730     } catch (...) {
90731       {
90732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90733       };
90734     }
90735   }
90736
90737   jresult = result;
90738
90739   //argout typemap for const std::string&
90740
90741   return jresult;
90742 }
90743
90744
90745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
90746   unsigned int jresult ;
90747   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90748   std::string *arg2 = 0 ;
90749   Dali::ImageDimensions arg3 ;
90750   Dali::FittingMode::Type arg4 ;
90751   Dali::SamplingMode::Type arg5 ;
90752   bool arg6 ;
90753   Dali::ImageDimensions *argp3 ;
90754   uint32_t result;
90755
90756   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90757   if (!jarg2) {
90758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90759     return 0;
90760   }
90761   std::string arg2_str(jarg2);
90762   arg2 = &arg2_str;
90763   argp3 = (Dali::ImageDimensions *)jarg3;
90764   if (!argp3) {
90765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90766     return 0;
90767   }
90768   arg3 = *argp3;
90769   arg4 = (Dali::FittingMode::Type)jarg4;
90770   arg5 = (Dali::SamplingMode::Type)jarg5;
90771   arg6 = jarg6 ? true : false;
90772   {
90773     try {
90774       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
90775     } catch (std::out_of_range& e) {
90776       {
90777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90778       };
90779     } catch (std::exception& e) {
90780       {
90781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90782       };
90783     } catch (Dali::DaliException e) {
90784       {
90785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90786       };
90787     } catch (...) {
90788       {
90789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90790       };
90791     }
90792   }
90793
90794   jresult = result;
90795
90796   //argout typemap for const std::string&
90797
90798   return jresult;
90799 }
90800
90801
90802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
90803   unsigned int jresult ;
90804   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90805   uint32_t arg2 ;
90806   bool result;
90807
90808   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90809   arg2 = (uint32_t)jarg2;
90810   {
90811     try {
90812       result = (bool)(arg1)->Cancel(arg2);
90813     } catch (std::out_of_range& e) {
90814       {
90815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90816       };
90817     } catch (std::exception& e) {
90818       {
90819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90820       };
90821     } catch (Dali::DaliException e) {
90822       {
90823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90824       };
90825     } catch (...) {
90826       {
90827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90828       };
90829     }
90830   }
90831
90832   jresult = result;
90833   return jresult;
90834 }
90835
90836
90837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
90838   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90839
90840   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90841   {
90842     try {
90843       (arg1)->CancelAll();
90844     } catch (std::out_of_range& e) {
90845       {
90846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90847       };
90848     } catch (std::exception& e) {
90849       {
90850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90851       };
90852     } catch (Dali::DaliException e) {
90853       {
90854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90855       };
90856     } catch (...) {
90857       {
90858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90859       };
90860     }
90861   }
90862
90863 }
90864
90865
90866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
90867   void * jresult ;
90868   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
90869   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
90870
90871   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
90872   {
90873     try {
90874       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
90875     } catch (std::out_of_range& e) {
90876       {
90877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90878       };
90879     } catch (std::exception& e) {
90880       {
90881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90882       };
90883     } catch (Dali::DaliException e) {
90884       {
90885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90886       };
90887     } catch (...) {
90888       {
90889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90890       };
90891     }
90892   }
90893
90894   jresult = (void *)result;
90895   return jresult;
90896 }
90897
90898
90899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
90900   void * jresult ;
90901   std::string *arg1 = 0 ;
90902   Dali::PixelData result;
90903
90904   if (!jarg1) {
90905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90906     return 0;
90907   }
90908   std::string arg1_str(jarg1);
90909   arg1 = &arg1_str;
90910   {
90911     try {
90912       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
90913     } catch (std::out_of_range& e) {
90914       {
90915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90916       };
90917     } catch (std::exception& e) {
90918       {
90919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90920       };
90921     } catch (Dali::DaliException e) {
90922       {
90923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90924       };
90925     } catch (...) {
90926       {
90927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90928       };
90929     }
90930   }
90931
90932   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90933
90934   //argout typemap for const std::string&
90935
90936   return jresult;
90937 }
90938
90939
90940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
90941   void * jresult ;
90942   std::string *arg1 = 0 ;
90943   Dali::ImageDimensions arg2 ;
90944   Dali::ImageDimensions *argp2 ;
90945   Dali::PixelData result;
90946
90947   if (!jarg1) {
90948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90949     return 0;
90950   }
90951   std::string arg1_str(jarg1);
90952   arg1 = &arg1_str;
90953   argp2 = (Dali::ImageDimensions *)jarg2;
90954   if (!argp2) {
90955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
90956     return 0;
90957   }
90958   arg2 = *argp2;
90959   {
90960     try {
90961       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
90962     } catch (std::out_of_range& e) {
90963       {
90964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90965       };
90966     } catch (std::exception& e) {
90967       {
90968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90969       };
90970     } catch (Dali::DaliException e) {
90971       {
90972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90973       };
90974     } catch (...) {
90975       {
90976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90977       };
90978     }
90979   }
90980
90981   jresult = new Dali::PixelData((const Dali::PixelData &)result);
90982
90983   //argout typemap for const std::string&
90984
90985   return jresult;
90986 }
90987
90988
90989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
90990   void * jresult ;
90991   std::string *arg1 = 0 ;
90992   Dali::ImageDimensions arg2 ;
90993   Dali::FittingMode::Type arg3 ;
90994   Dali::SamplingMode::Type arg4 ;
90995   bool arg5 ;
90996   Dali::ImageDimensions *argp2 ;
90997   Dali::PixelData result;
90998
90999   if (!jarg1) {
91000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91001     return 0;
91002   }
91003   std::string arg1_str(jarg1);
91004   arg1 = &arg1_str;
91005   argp2 = (Dali::ImageDimensions *)jarg2;
91006   if (!argp2) {
91007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91008     return 0;
91009   }
91010   arg2 = *argp2;
91011   arg3 = (Dali::FittingMode::Type)jarg3;
91012   arg4 = (Dali::SamplingMode::Type)jarg4;
91013   arg5 = jarg5 ? true : false;
91014   {
91015     try {
91016       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91017     } catch (std::out_of_range& e) {
91018       {
91019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91020       };
91021     } catch (std::exception& e) {
91022       {
91023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91024       };
91025     } catch (Dali::DaliException e) {
91026       {
91027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91028       };
91029     } catch (...) {
91030       {
91031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91032       };
91033     }
91034   }
91035
91036   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91037
91038   //argout typemap for const std::string&
91039
91040   return jresult;
91041 }
91042
91043
91044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91045   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91046
91047   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91048   {
91049     try {
91050       delete arg1;
91051     } catch (std::out_of_range& e) {
91052       {
91053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91054       };
91055     } catch (std::exception& e) {
91056       {
91057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91058       };
91059     } catch (Dali::DaliException e) {
91060       {
91061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91062       };
91063     } catch (...) {
91064       {
91065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91066       };
91067     }
91068   }
91069
91070 }
91071
91072
91073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
91074   void * jresult ;
91075   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91076   Dali::Actor arg2 ;
91077   Dali::Actor arg3 ;
91078   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
91079   Dali::Actor *argp2 ;
91080   Dali::Actor *argp3 ;
91081   Dali::Actor result;
91082
91083   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91084   argp2 = (Dali::Actor *)jarg2;
91085   if (!argp2) {
91086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91087     return 0;
91088   }
91089   arg2 = *argp2;
91090   argp3 = (Dali::Actor *)jarg3;
91091   if (!argp3) {
91092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91093     return 0;
91094   }
91095   arg3 = *argp3;
91096   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
91097   {
91098     try {
91099       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
91100     } catch (std::out_of_range& e) {
91101       {
91102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91103       };
91104     } catch (std::exception& e) {
91105       {
91106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91107       };
91108     } catch (Dali::DaliException e) {
91109       {
91110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91111       };
91112     } catch (...) {
91113       {
91114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91115       };
91116     }
91117   }
91118
91119   jresult = new Dali::Actor((const Dali::Actor &)result);
91120   return jresult;
91121 }
91122
91123
91124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
91125   void * jresult ;
91126   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
91127
91128   {
91129     try {
91130       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
91131     } catch (std::out_of_range& e) {
91132       {
91133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91134       };
91135     } catch (std::exception& e) {
91136       {
91137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91138       };
91139     } catch (Dali::DaliException e) {
91140       {
91141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91142       };
91143     } catch (...) {
91144       {
91145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91146       };
91147     }
91148   }
91149
91150   jresult = (void *)result;
91151   return jresult;
91152 }
91153
91154
91155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
91156   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
91157   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
91158   if (director) {
91159     director->swig_connect_director(callback0);
91160   }
91161 }
91162
91163
91164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
91165   KeyboardFocusManager arg1 ;
91166   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
91167   KeyboardFocusManager *argp1 ;
91168
91169   argp1 = (KeyboardFocusManager *)jarg1;
91170   if (!argp1) {
91171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
91172     return ;
91173   }
91174   arg1 = *argp1;
91175   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
91176   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
91177   {
91178     try {
91179       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
91180     } catch (std::out_of_range& e) {
91181       {
91182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91183       };
91184     } catch (std::exception& e) {
91185       {
91186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91187       };
91188     } catch (Dali::DaliException e) {
91189       {
91190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91191       };
91192     } catch (...) {
91193       {
91194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91195       };
91196     }
91197   }
91198
91199 }
91200
91201
91202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
91203   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91204
91205   arg1 = (std::vector< unsigned int > *)jarg1;
91206   {
91207     try {
91208       (arg1)->clear();
91209     } catch (std::out_of_range& e) {
91210       {
91211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91212       };
91213     } catch (std::exception& e) {
91214       {
91215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91216       };
91217     } catch (Dali::DaliException e) {
91218       {
91219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91220       };
91221     } catch (...) {
91222       {
91223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91224       };
91225     }
91226   }
91227
91228 }
91229
91230
91231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
91232   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91233   unsigned int *arg2 = 0 ;
91234   unsigned int temp2 ;
91235
91236   arg1 = (std::vector< unsigned int > *)jarg1;
91237   temp2 = (unsigned int)jarg2;
91238   arg2 = &temp2;
91239   {
91240     try {
91241       (arg1)->push_back((unsigned int const &)*arg2);
91242     } catch (std::out_of_range& e) {
91243       {
91244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91245       };
91246     } catch (std::exception& e) {
91247       {
91248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91249       };
91250     } catch (Dali::DaliException e) {
91251       {
91252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91253       };
91254     } catch (...) {
91255       {
91256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91257       };
91258     }
91259   }
91260
91261 }
91262
91263
91264 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
91265   unsigned long jresult ;
91266   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91267   std::vector< unsigned int >::size_type result;
91268
91269   arg1 = (std::vector< unsigned int > *)jarg1;
91270   {
91271     try {
91272       result = ((std::vector< unsigned int > const *)arg1)->size();
91273     } catch (std::out_of_range& e) {
91274       {
91275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91276       };
91277     } catch (std::exception& e) {
91278       {
91279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91280       };
91281     } catch (Dali::DaliException e) {
91282       {
91283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91284       };
91285     } catch (...) {
91286       {
91287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91288       };
91289     }
91290   }
91291
91292   jresult = (unsigned long)result;
91293   return jresult;
91294 }
91295
91296
91297 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
91298   unsigned long jresult ;
91299   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91300   std::vector< unsigned int >::size_type result;
91301
91302   arg1 = (std::vector< unsigned int > *)jarg1;
91303   {
91304     try {
91305       result = ((std::vector< unsigned int > const *)arg1)->capacity();
91306     } catch (std::out_of_range& e) {
91307       {
91308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91309       };
91310     } catch (std::exception& e) {
91311       {
91312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91313       };
91314     } catch (Dali::DaliException e) {
91315       {
91316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91317       };
91318     } catch (...) {
91319       {
91320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91321       };
91322     }
91323   }
91324
91325   jresult = (unsigned long)result;
91326   return jresult;
91327 }
91328
91329
91330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
91331   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91332   std::vector< unsigned int >::size_type arg2 ;
91333
91334   arg1 = (std::vector< unsigned int > *)jarg1;
91335   arg2 = (std::vector< unsigned int >::size_type)jarg2;
91336   {
91337     try {
91338       (arg1)->reserve(arg2);
91339     } catch (std::out_of_range& e) {
91340       {
91341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91342       };
91343     } catch (std::exception& e) {
91344       {
91345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91346       };
91347     } catch (Dali::DaliException e) {
91348       {
91349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91350       };
91351     } catch (...) {
91352       {
91353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91354       };
91355     }
91356   }
91357
91358 }
91359
91360
91361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
91362   void * jresult ;
91363   std::vector< unsigned int > *result = 0 ;
91364
91365   {
91366     try {
91367       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
91368     } catch (std::out_of_range& e) {
91369       {
91370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91371       };
91372     } catch (std::exception& e) {
91373       {
91374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91375       };
91376     } catch (Dali::DaliException e) {
91377       {
91378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91379       };
91380     } catch (...) {
91381       {
91382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91383       };
91384     }
91385   }
91386
91387   jresult = (void *)result;
91388   return jresult;
91389 }
91390
91391
91392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
91393   void * jresult ;
91394   std::vector< unsigned int > *arg1 = 0 ;
91395   std::vector< unsigned int > *result = 0 ;
91396
91397   arg1 = (std::vector< unsigned int > *)jarg1;
91398   if (!arg1) {
91399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91400     return 0;
91401   }
91402   {
91403     try {
91404       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
91405     } catch (std::out_of_range& e) {
91406       {
91407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91408       };
91409     } catch (std::exception& e) {
91410       {
91411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91412       };
91413     } catch (Dali::DaliException e) {
91414       {
91415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91416       };
91417     } catch (...) {
91418       {
91419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91420       };
91421     }
91422   }
91423
91424   jresult = (void *)result;
91425   return jresult;
91426 }
91427
91428
91429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
91430   void * jresult ;
91431   int arg1 ;
91432   std::vector< unsigned int > *result = 0 ;
91433
91434   arg1 = (int)jarg1;
91435   {
91436     try {
91437       try {
91438         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
91439       }
91440       catch(std::out_of_range &_e) {
91441         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91442         return 0;
91443       }
91444
91445     } catch (std::out_of_range& e) {
91446       {
91447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91448       };
91449     } catch (std::exception& e) {
91450       {
91451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91452       };
91453     } catch (Dali::DaliException e) {
91454       {
91455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91456       };
91457     } catch (...) {
91458       {
91459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91460       };
91461     }
91462   }
91463
91464   jresult = (void *)result;
91465   return jresult;
91466 }
91467
91468
91469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
91470   unsigned int jresult ;
91471   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91472   int arg2 ;
91473   unsigned int result;
91474
91475   arg1 = (std::vector< unsigned int > *)jarg1;
91476   arg2 = (int)jarg2;
91477   {
91478     try {
91479       try {
91480         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
91481       }
91482       catch(std::out_of_range &_e) {
91483         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91484         return 0;
91485       }
91486
91487     } catch (std::out_of_range& e) {
91488       {
91489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91490       };
91491     } catch (std::exception& e) {
91492       {
91493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91494       };
91495     } catch (Dali::DaliException e) {
91496       {
91497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91498       };
91499     } catch (...) {
91500       {
91501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91502       };
91503     }
91504   }
91505
91506   jresult = result;
91507   return jresult;
91508 }
91509
91510
91511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
91512   unsigned int jresult ;
91513   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91514   int arg2 ;
91515   unsigned int *result = 0 ;
91516
91517   arg1 = (std::vector< unsigned int > *)jarg1;
91518   arg2 = (int)jarg2;
91519   {
91520     try {
91521       try {
91522         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
91523       }
91524       catch(std::out_of_range &_e) {
91525         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91526         return 0;
91527       }
91528
91529     } catch (std::out_of_range& e) {
91530       {
91531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91532       };
91533     } catch (std::exception& e) {
91534       {
91535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91536       };
91537     } catch (Dali::DaliException e) {
91538       {
91539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91540       };
91541     } catch (...) {
91542       {
91543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91544       };
91545     }
91546   }
91547
91548   jresult = *result;
91549   return jresult;
91550 }
91551
91552
91553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
91554   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91555   int arg2 ;
91556   unsigned int *arg3 = 0 ;
91557   unsigned int temp3 ;
91558
91559   arg1 = (std::vector< unsigned int > *)jarg1;
91560   arg2 = (int)jarg2;
91561   temp3 = (unsigned int)jarg3;
91562   arg3 = &temp3;
91563   {
91564     try {
91565       try {
91566         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
91567       }
91568       catch(std::out_of_range &_e) {
91569         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91570         return ;
91571       }
91572
91573     } catch (std::out_of_range& e) {
91574       {
91575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91576       };
91577     } catch (std::exception& e) {
91578       {
91579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91580       };
91581     } catch (Dali::DaliException e) {
91582       {
91583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91584       };
91585     } catch (...) {
91586       {
91587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91588       };
91589     }
91590   }
91591
91592 }
91593
91594
91595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
91596   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91597   std::vector< unsigned int > *arg2 = 0 ;
91598
91599   arg1 = (std::vector< unsigned int > *)jarg1;
91600   arg2 = (std::vector< unsigned int > *)jarg2;
91601   if (!arg2) {
91602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91603     return ;
91604   }
91605   {
91606     try {
91607       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
91608     } catch (std::out_of_range& e) {
91609       {
91610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91611       };
91612     } catch (std::exception& e) {
91613       {
91614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91615       };
91616     } catch (Dali::DaliException e) {
91617       {
91618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91619       };
91620     } catch (...) {
91621       {
91622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91623       };
91624     }
91625   }
91626
91627 }
91628
91629
91630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91631   void * jresult ;
91632   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91633   int arg2 ;
91634   int arg3 ;
91635   std::vector< unsigned int > *result = 0 ;
91636
91637   arg1 = (std::vector< unsigned int > *)jarg1;
91638   arg2 = (int)jarg2;
91639   arg3 = (int)jarg3;
91640   {
91641     try {
91642       try {
91643         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
91644       }
91645       catch(std::out_of_range &_e) {
91646         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91647         return 0;
91648       }
91649       catch(std::invalid_argument &_e) {
91650         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91651         return 0;
91652       }
91653
91654     } catch (std::out_of_range& e) {
91655       {
91656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91657       };
91658     } catch (std::exception& e) {
91659       {
91660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91661       };
91662     } catch (Dali::DaliException e) {
91663       {
91664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91665       };
91666     } catch (...) {
91667       {
91668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91669       };
91670     }
91671   }
91672
91673   jresult = (void *)result;
91674   return jresult;
91675 }
91676
91677
91678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
91679   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91680   int arg2 ;
91681   unsigned int *arg3 = 0 ;
91682   unsigned int temp3 ;
91683
91684   arg1 = (std::vector< unsigned int > *)jarg1;
91685   arg2 = (int)jarg2;
91686   temp3 = (unsigned int)jarg3;
91687   arg3 = &temp3;
91688   {
91689     try {
91690       try {
91691         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
91692       }
91693       catch(std::out_of_range &_e) {
91694         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91695         return ;
91696       }
91697
91698     } catch (std::out_of_range& e) {
91699       {
91700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91701       };
91702     } catch (std::exception& e) {
91703       {
91704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91705       };
91706     } catch (Dali::DaliException e) {
91707       {
91708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91709       };
91710     } catch (...) {
91711       {
91712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91713       };
91714     }
91715   }
91716
91717 }
91718
91719
91720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91721   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91722   int arg2 ;
91723   std::vector< unsigned int > *arg3 = 0 ;
91724
91725   arg1 = (std::vector< unsigned int > *)jarg1;
91726   arg2 = (int)jarg2;
91727   arg3 = (std::vector< unsigned int > *)jarg3;
91728   if (!arg3) {
91729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91730     return ;
91731   }
91732   {
91733     try {
91734       try {
91735         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91736       }
91737       catch(std::out_of_range &_e) {
91738         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91739         return ;
91740       }
91741
91742     } catch (std::out_of_range& e) {
91743       {
91744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91745       };
91746     } catch (std::exception& e) {
91747       {
91748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91749       };
91750     } catch (Dali::DaliException e) {
91751       {
91752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91753       };
91754     } catch (...) {
91755       {
91756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91757       };
91758     }
91759   }
91760
91761 }
91762
91763
91764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
91765   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91766   int arg2 ;
91767
91768   arg1 = (std::vector< unsigned int > *)jarg1;
91769   arg2 = (int)jarg2;
91770   {
91771     try {
91772       try {
91773         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
91774       }
91775       catch(std::out_of_range &_e) {
91776         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91777         return ;
91778       }
91779
91780     } catch (std::out_of_range& e) {
91781       {
91782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91783       };
91784     } catch (std::exception& e) {
91785       {
91786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91787       };
91788     } catch (Dali::DaliException e) {
91789       {
91790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91791       };
91792     } catch (...) {
91793       {
91794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91795       };
91796     }
91797   }
91798
91799 }
91800
91801
91802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91803   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91804   int arg2 ;
91805   int arg3 ;
91806
91807   arg1 = (std::vector< unsigned int > *)jarg1;
91808   arg2 = (int)jarg2;
91809   arg3 = (int)jarg3;
91810   {
91811     try {
91812       try {
91813         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
91814       }
91815       catch(std::out_of_range &_e) {
91816         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91817         return ;
91818       }
91819       catch(std::invalid_argument &_e) {
91820         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91821         return ;
91822       }
91823
91824     } catch (std::out_of_range& e) {
91825       {
91826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91827       };
91828     } catch (std::exception& e) {
91829       {
91830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91831       };
91832     } catch (Dali::DaliException e) {
91833       {
91834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91835       };
91836     } catch (...) {
91837       {
91838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91839       };
91840     }
91841   }
91842
91843 }
91844
91845
91846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
91847   void * jresult ;
91848   unsigned int *arg1 = 0 ;
91849   int arg2 ;
91850   unsigned int temp1 ;
91851   std::vector< unsigned int > *result = 0 ;
91852
91853   temp1 = (unsigned int)jarg1;
91854   arg1 = &temp1;
91855   arg2 = (int)jarg2;
91856   {
91857     try {
91858       try {
91859         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
91860       }
91861       catch(std::out_of_range &_e) {
91862         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91863         return 0;
91864       }
91865
91866     } catch (std::out_of_range& e) {
91867       {
91868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91869       };
91870     } catch (std::exception& e) {
91871       {
91872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91873       };
91874     } catch (Dali::DaliException e) {
91875       {
91876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91877       };
91878     } catch (...) {
91879       {
91880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91881       };
91882     }
91883   }
91884
91885   jresult = (void *)result;
91886   return jresult;
91887 }
91888
91889
91890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
91891   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91892
91893   arg1 = (std::vector< unsigned int > *)jarg1;
91894   {
91895     try {
91896       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
91897     } catch (std::out_of_range& e) {
91898       {
91899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91900       };
91901     } catch (std::exception& e) {
91902       {
91903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91904       };
91905     } catch (Dali::DaliException e) {
91906       {
91907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91908       };
91909     } catch (...) {
91910       {
91911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91912       };
91913     }
91914   }
91915
91916 }
91917
91918
91919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
91920   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91921   int arg2 ;
91922   int arg3 ;
91923
91924   arg1 = (std::vector< unsigned int > *)jarg1;
91925   arg2 = (int)jarg2;
91926   arg3 = (int)jarg3;
91927   {
91928     try {
91929       try {
91930         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
91931       }
91932       catch(std::out_of_range &_e) {
91933         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91934         return ;
91935       }
91936       catch(std::invalid_argument &_e) {
91937         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91938         return ;
91939       }
91940
91941     } catch (std::out_of_range& e) {
91942       {
91943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91944       };
91945     } catch (std::exception& e) {
91946       {
91947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91948       };
91949     } catch (Dali::DaliException e) {
91950       {
91951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91952       };
91953     } catch (...) {
91954       {
91955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91956       };
91957     }
91958   }
91959
91960 }
91961
91962
91963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
91964   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
91965   int arg2 ;
91966   std::vector< unsigned int > *arg3 = 0 ;
91967
91968   arg1 = (std::vector< unsigned int > *)jarg1;
91969   arg2 = (int)jarg2;
91970   arg3 = (std::vector< unsigned int > *)jarg3;
91971   if (!arg3) {
91972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
91973     return ;
91974   }
91975   {
91976     try {
91977       try {
91978         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
91979       }
91980       catch(std::out_of_range &_e) {
91981         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91982         return ;
91983       }
91984
91985     } catch (std::out_of_range& e) {
91986       {
91987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91988       };
91989     } catch (std::exception& e) {
91990       {
91991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91992       };
91993     } catch (Dali::DaliException e) {
91994       {
91995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91996       };
91997     } catch (...) {
91998       {
91999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92000       };
92001     }
92002   }
92003
92004 }
92005
92006
92007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92008   unsigned int jresult ;
92009   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92010   unsigned int *arg2 = 0 ;
92011   unsigned int temp2 ;
92012   bool result;
92013
92014   arg1 = (std::vector< unsigned int > *)jarg1;
92015   temp2 = (unsigned int)jarg2;
92016   arg2 = &temp2;
92017   {
92018     try {
92019       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92020     } catch (std::out_of_range& e) {
92021       {
92022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92023       };
92024     } catch (std::exception& e) {
92025       {
92026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92027       };
92028     } catch (Dali::DaliException e) {
92029       {
92030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92031       };
92032     } catch (...) {
92033       {
92034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92035       };
92036     }
92037   }
92038
92039   jresult = result;
92040   return jresult;
92041 }
92042
92043
92044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92045   int jresult ;
92046   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92047   unsigned int *arg2 = 0 ;
92048   unsigned int temp2 ;
92049   int result;
92050
92051   arg1 = (std::vector< unsigned int > *)jarg1;
92052   temp2 = (unsigned int)jarg2;
92053   arg2 = &temp2;
92054   {
92055     try {
92056       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92057     } catch (std::out_of_range& e) {
92058       {
92059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92060       };
92061     } catch (std::exception& e) {
92062       {
92063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92064       };
92065     } catch (Dali::DaliException e) {
92066       {
92067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92068       };
92069     } catch (...) {
92070       {
92071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92072       };
92073     }
92074   }
92075
92076   jresult = result;
92077   return jresult;
92078 }
92079
92080
92081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
92082   int jresult ;
92083   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92084   unsigned int *arg2 = 0 ;
92085   unsigned int temp2 ;
92086   int result;
92087
92088   arg1 = (std::vector< unsigned int > *)jarg1;
92089   temp2 = (unsigned int)jarg2;
92090   arg2 = &temp2;
92091   {
92092     try {
92093       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
92094     } catch (std::out_of_range& e) {
92095       {
92096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92097       };
92098     } catch (std::exception& e) {
92099       {
92100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92101       };
92102     } catch (Dali::DaliException e) {
92103       {
92104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92105       };
92106     } catch (...) {
92107       {
92108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92109       };
92110     }
92111   }
92112
92113   jresult = result;
92114   return jresult;
92115 }
92116
92117
92118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
92119   unsigned int jresult ;
92120   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92121   unsigned int *arg2 = 0 ;
92122   unsigned int temp2 ;
92123   bool result;
92124
92125   arg1 = (std::vector< unsigned int > *)jarg1;
92126   temp2 = (unsigned int)jarg2;
92127   arg2 = &temp2;
92128   {
92129     try {
92130       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
92131     } catch (std::out_of_range& e) {
92132       {
92133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92134       };
92135     } catch (std::exception& e) {
92136       {
92137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92138       };
92139     } catch (Dali::DaliException e) {
92140       {
92141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92142       };
92143     } catch (...) {
92144       {
92145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92146       };
92147     }
92148   }
92149
92150   jresult = result;
92151   return jresult;
92152 }
92153
92154
92155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
92156   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92157
92158   arg1 = (std::vector< unsigned int > *)jarg1;
92159   {
92160     try {
92161       delete arg1;
92162     } catch (std::out_of_range& e) {
92163       {
92164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92165       };
92166     } catch (std::exception& e) {
92167       {
92168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92169       };
92170     } catch (Dali::DaliException e) {
92171       {
92172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92173       };
92174     } catch (...) {
92175       {
92176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92177       };
92178     }
92179   }
92180
92181 }
92182
92183
92184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
92185   void * jresult ;
92186   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92187
92188   {
92189     try {
92190       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
92191     } catch (std::out_of_range& e) {
92192       {
92193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92194       };
92195     } catch (std::exception& e) {
92196       {
92197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92198       };
92199     } catch (Dali::DaliException e) {
92200       {
92201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92202       };
92203     } catch (...) {
92204       {
92205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92206       };
92207     }
92208   }
92209
92210   jresult = (void *)result;
92211   return jresult;
92212 }
92213
92214
92215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
92216   void * jresult ;
92217   unsigned int arg1 ;
92218   Dali::Actor arg2 ;
92219   Dali::Actor *argp2 ;
92220   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92221
92222   arg1 = (unsigned int)jarg1;
92223   argp2 = (Dali::Actor *)jarg2;
92224   if (!argp2) {
92225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92226     return 0;
92227   }
92228   arg2 = *argp2;
92229   {
92230     try {
92231       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
92232     } catch (std::out_of_range& e) {
92233       {
92234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92235       };
92236     } catch (std::exception& e) {
92237       {
92238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92239       };
92240     } catch (Dali::DaliException e) {
92241       {
92242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92243       };
92244     } catch (...) {
92245       {
92246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92247       };
92248     }
92249   }
92250
92251   jresult = (void *)result;
92252   return jresult;
92253 }
92254
92255
92256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
92257   void * jresult ;
92258   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
92259   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92260
92261   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92262   if (!arg1) {
92263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92264     return 0;
92265   }
92266   {
92267     try {
92268       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
92269     } catch (std::out_of_range& e) {
92270       {
92271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92272       };
92273     } catch (std::exception& e) {
92274       {
92275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92276       };
92277     } catch (Dali::DaliException e) {
92278       {
92279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92280       };
92281     } catch (...) {
92282       {
92283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92284       };
92285     }
92286   }
92287
92288   jresult = (void *)result;
92289   return jresult;
92290 }
92291
92292
92293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
92294   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92295   unsigned int arg2 ;
92296
92297   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92298   arg2 = (unsigned int)jarg2;
92299   if (arg1) (arg1)->first = arg2;
92300 }
92301
92302
92303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
92304   unsigned int jresult ;
92305   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92306   unsigned int result;
92307
92308   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92309   result = (unsigned int) ((arg1)->first);
92310   jresult = result;
92311   return jresult;
92312 }
92313
92314
92315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
92316   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92317   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
92318
92319   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92320   arg2 = (Dali::Actor *)jarg2;
92321   if (arg1) (arg1)->second = *arg2;
92322 }
92323
92324
92325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
92326   void * jresult ;
92327   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92328   Dali::Actor *result = 0 ;
92329
92330   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92331   result = (Dali::Actor *)& ((arg1)->second);
92332   jresult = (void *)result;
92333   return jresult;
92334 }
92335
92336
92337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
92338   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
92339
92340   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
92341   {
92342     try {
92343       delete arg1;
92344     } catch (std::out_of_range& e) {
92345       {
92346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92347       };
92348     } catch (std::exception& e) {
92349       {
92350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92351       };
92352     } catch (Dali::DaliException e) {
92353       {
92354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92355       };
92356     } catch (...) {
92357       {
92358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92359       };
92360     }
92361   }
92362
92363 }
92364
92365
92366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
92367   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92368
92369   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92370   {
92371     try {
92372       (arg1)->clear();
92373     } catch (std::out_of_range& e) {
92374       {
92375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92376       };
92377     } catch (std::exception& e) {
92378       {
92379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92380       };
92381     } catch (Dali::DaliException e) {
92382       {
92383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92384       };
92385     } catch (...) {
92386       {
92387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92388       };
92389     }
92390   }
92391
92392 }
92393
92394
92395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
92396   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92397   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
92398
92399   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92400   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
92401   if (!arg2) {
92402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92403     return ;
92404   }
92405   {
92406     try {
92407       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
92408     } catch (std::out_of_range& e) {
92409       {
92410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92411       };
92412     } catch (std::exception& e) {
92413       {
92414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92415       };
92416     } catch (Dali::DaliException e) {
92417       {
92418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92419       };
92420     } catch (...) {
92421       {
92422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92423       };
92424     }
92425   }
92426
92427 }
92428
92429
92430 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
92431   unsigned long jresult ;
92432   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92433   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92434
92435   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92436   {
92437     try {
92438       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
92439     } catch (std::out_of_range& e) {
92440       {
92441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92442       };
92443     } catch (std::exception& e) {
92444       {
92445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92446       };
92447     } catch (Dali::DaliException e) {
92448       {
92449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92450       };
92451     } catch (...) {
92452       {
92453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92454       };
92455     }
92456   }
92457
92458   jresult = (unsigned long)result;
92459   return jresult;
92460 }
92461
92462
92463 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
92464   unsigned long jresult ;
92465   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92466   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
92467
92468   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92469   {
92470     try {
92471       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
92472     } catch (std::out_of_range& e) {
92473       {
92474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92475       };
92476     } catch (std::exception& e) {
92477       {
92478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92479       };
92480     } catch (Dali::DaliException e) {
92481       {
92482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92483       };
92484     } catch (...) {
92485       {
92486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92487       };
92488     }
92489   }
92490
92491   jresult = (unsigned long)result;
92492   return jresult;
92493 }
92494
92495
92496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
92497   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92498   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
92499
92500   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92501   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
92502   {
92503     try {
92504       (arg1)->reserve(arg2);
92505     } catch (std::out_of_range& e) {
92506       {
92507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92508       };
92509     } catch (std::exception& e) {
92510       {
92511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92512       };
92513     } catch (Dali::DaliException e) {
92514       {
92515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92516       };
92517     } catch (...) {
92518       {
92519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92520       };
92521     }
92522   }
92523
92524 }
92525
92526
92527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
92528   void * jresult ;
92529   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92530
92531   {
92532     try {
92533       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
92534     } catch (std::out_of_range& e) {
92535       {
92536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92537       };
92538     } catch (std::exception& e) {
92539       {
92540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92541       };
92542     } catch (Dali::DaliException e) {
92543       {
92544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92545       };
92546     } catch (...) {
92547       {
92548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92549       };
92550     }
92551   }
92552
92553   jresult = (void *)result;
92554   return jresult;
92555 }
92556
92557
92558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
92559   void * jresult ;
92560   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
92561   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92562
92563   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92564   if (!arg1) {
92565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92566     return 0;
92567   }
92568   {
92569     try {
92570       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);
92571     } catch (std::out_of_range& e) {
92572       {
92573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92574       };
92575     } catch (std::exception& e) {
92576       {
92577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92578       };
92579     } catch (Dali::DaliException e) {
92580       {
92581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92582       };
92583     } catch (...) {
92584       {
92585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92586       };
92587     }
92588   }
92589
92590   jresult = (void *)result;
92591   return jresult;
92592 }
92593
92594
92595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
92596   void * jresult ;
92597   int arg1 ;
92598   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92599
92600   arg1 = (int)jarg1;
92601   {
92602     try {
92603       try {
92604         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);
92605       }
92606       catch(std::out_of_range &_e) {
92607         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92608         return 0;
92609       }
92610
92611     } catch (std::out_of_range& e) {
92612       {
92613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92614       };
92615     } catch (std::exception& e) {
92616       {
92617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92618       };
92619     } catch (Dali::DaliException e) {
92620       {
92621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92622       };
92623     } catch (...) {
92624       {
92625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92626       };
92627     }
92628   }
92629
92630   jresult = (void *)result;
92631   return jresult;
92632 }
92633
92634
92635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
92636   void * jresult ;
92637   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92638   int arg2 ;
92639   std::pair< unsigned int,Dali::Actor > result;
92640
92641   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92642   arg2 = (int)jarg2;
92643   {
92644     try {
92645       try {
92646         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
92647       }
92648       catch(std::out_of_range &_e) {
92649         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92650         return 0;
92651       }
92652
92653     } catch (std::out_of_range& e) {
92654       {
92655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92656       };
92657     } catch (std::exception& e) {
92658       {
92659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92660       };
92661     } catch (Dali::DaliException e) {
92662       {
92663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92664       };
92665     } catch (...) {
92666       {
92667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92668       };
92669     }
92670   }
92671
92672   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
92673   return jresult;
92674 }
92675
92676
92677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
92678   void * jresult ;
92679   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92680   int arg2 ;
92681   std::pair< unsigned int,Dali::Actor > *result = 0 ;
92682
92683   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92684   arg2 = (int)jarg2;
92685   {
92686     try {
92687       try {
92688         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
92689       }
92690       catch(std::out_of_range &_e) {
92691         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92692         return 0;
92693       }
92694
92695     } catch (std::out_of_range& e) {
92696       {
92697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92698       };
92699     } catch (std::exception& e) {
92700       {
92701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92702       };
92703     } catch (Dali::DaliException e) {
92704       {
92705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92706       };
92707     } catch (...) {
92708       {
92709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92710       };
92711     }
92712   }
92713
92714   jresult = (void *)result;
92715   return jresult;
92716 }
92717
92718
92719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
92720   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92721   int arg2 ;
92722   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92723
92724   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92725   arg2 = (int)jarg2;
92726   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92727   if (!arg3) {
92728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92729     return ;
92730   }
92731   {
92732     try {
92733       try {
92734         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);
92735       }
92736       catch(std::out_of_range &_e) {
92737         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92738         return ;
92739       }
92740
92741     } catch (std::out_of_range& e) {
92742       {
92743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92744       };
92745     } catch (std::exception& e) {
92746       {
92747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92748       };
92749     } catch (Dali::DaliException e) {
92750       {
92751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92752       };
92753     } catch (...) {
92754       {
92755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92756       };
92757     }
92758   }
92759
92760 }
92761
92762
92763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
92764   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92765   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
92766
92767   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92768   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
92769   if (!arg2) {
92770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92771     return ;
92772   }
92773   {
92774     try {
92775       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);
92776     } catch (std::out_of_range& e) {
92777       {
92778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92779       };
92780     } catch (std::exception& e) {
92781       {
92782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92783       };
92784     } catch (Dali::DaliException e) {
92785       {
92786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92787       };
92788     } catch (...) {
92789       {
92790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92791       };
92792     }
92793   }
92794
92795 }
92796
92797
92798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92799   void * jresult ;
92800   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92801   int arg2 ;
92802   int arg3 ;
92803   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
92804
92805   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92806   arg2 = (int)jarg2;
92807   arg3 = (int)jarg3;
92808   {
92809     try {
92810       try {
92811         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);
92812       }
92813       catch(std::out_of_range &_e) {
92814         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92815         return 0;
92816       }
92817       catch(std::invalid_argument &_e) {
92818         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92819         return 0;
92820       }
92821
92822     } catch (std::out_of_range& e) {
92823       {
92824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92825       };
92826     } catch (std::exception& e) {
92827       {
92828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92829       };
92830     } catch (Dali::DaliException e) {
92831       {
92832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92833       };
92834     } catch (...) {
92835       {
92836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92837       };
92838     }
92839   }
92840
92841   jresult = (void *)result;
92842   return jresult;
92843 }
92844
92845
92846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
92847   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92848   int arg2 ;
92849   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
92850
92851   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92852   arg2 = (int)jarg2;
92853   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
92854   if (!arg3) {
92855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
92856     return ;
92857   }
92858   {
92859     try {
92860       try {
92861         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);
92862       }
92863       catch(std::out_of_range &_e) {
92864         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92865         return ;
92866       }
92867
92868     } catch (std::out_of_range& e) {
92869       {
92870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92871       };
92872     } catch (std::exception& e) {
92873       {
92874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92875       };
92876     } catch (Dali::DaliException e) {
92877       {
92878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92879       };
92880     } catch (...) {
92881       {
92882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92883       };
92884     }
92885   }
92886
92887 }
92888
92889
92890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92891   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92892   int arg2 ;
92893   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
92894
92895   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92896   arg2 = (int)jarg2;
92897   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
92898   if (!arg3) {
92899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
92900     return ;
92901   }
92902   {
92903     try {
92904       try {
92905         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);
92906       }
92907       catch(std::out_of_range &_e) {
92908         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92909         return ;
92910       }
92911
92912     } catch (std::out_of_range& e) {
92913       {
92914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92915       };
92916     } catch (std::exception& e) {
92917       {
92918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92919       };
92920     } catch (Dali::DaliException e) {
92921       {
92922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92923       };
92924     } catch (...) {
92925       {
92926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92927       };
92928     }
92929   }
92930
92931 }
92932
92933
92934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
92935   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92936   int arg2 ;
92937
92938   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92939   arg2 = (int)jarg2;
92940   {
92941     try {
92942       try {
92943         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
92944       }
92945       catch(std::out_of_range &_e) {
92946         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92947         return ;
92948       }
92949
92950     } catch (std::out_of_range& e) {
92951       {
92952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92953       };
92954     } catch (std::exception& e) {
92955       {
92956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92957       };
92958     } catch (Dali::DaliException e) {
92959       {
92960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92961       };
92962     } catch (...) {
92963       {
92964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92965       };
92966     }
92967   }
92968
92969 }
92970
92971
92972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92973   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92974   int arg2 ;
92975   int arg3 ;
92976
92977   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92978   arg2 = (int)jarg2;
92979   arg3 = (int)jarg3;
92980   {
92981     try {
92982       try {
92983         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
92984       }
92985       catch(std::out_of_range &_e) {
92986         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92987         return ;
92988       }
92989       catch(std::invalid_argument &_e) {
92990         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92991         return ;
92992       }
92993
92994     } catch (std::out_of_range& e) {
92995       {
92996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92997       };
92998     } catch (std::exception& e) {
92999       {
93000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93001       };
93002     } catch (Dali::DaliException e) {
93003       {
93004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93005       };
93006     } catch (...) {
93007       {
93008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93009       };
93010     }
93011   }
93012
93013 }
93014
93015
93016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93017   void * jresult ;
93018   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93019   int arg2 ;
93020   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93021
93022   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93023   if (!arg1) {
93024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93025     return 0;
93026   }
93027   arg2 = (int)jarg2;
93028   {
93029     try {
93030       try {
93031         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);
93032       }
93033       catch(std::out_of_range &_e) {
93034         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93035         return 0;
93036       }
93037
93038     } catch (std::out_of_range& e) {
93039       {
93040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93041       };
93042     } catch (std::exception& e) {
93043       {
93044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93045       };
93046     } catch (Dali::DaliException e) {
93047       {
93048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93049       };
93050     } catch (...) {
93051       {
93052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93053       };
93054     }
93055   }
93056
93057   jresult = (void *)result;
93058   return jresult;
93059 }
93060
93061
93062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93063   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93064
93065   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93066   {
93067     try {
93068       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
93069     } catch (std::out_of_range& e) {
93070       {
93071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93072       };
93073     } catch (std::exception& e) {
93074       {
93075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93076       };
93077     } catch (Dali::DaliException e) {
93078       {
93079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93080       };
93081     } catch (...) {
93082       {
93083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93084       };
93085     }
93086   }
93087
93088 }
93089
93090
93091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93092   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93093   int arg2 ;
93094   int arg3 ;
93095
93096   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93097   arg2 = (int)jarg2;
93098   arg3 = (int)jarg3;
93099   {
93100     try {
93101       try {
93102         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93103       }
93104       catch(std::out_of_range &_e) {
93105         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93106         return ;
93107       }
93108       catch(std::invalid_argument &_e) {
93109         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93110         return ;
93111       }
93112
93113     } catch (std::out_of_range& e) {
93114       {
93115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93116       };
93117     } catch (std::exception& e) {
93118       {
93119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93120       };
93121     } catch (Dali::DaliException e) {
93122       {
93123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93124       };
93125     } catch (...) {
93126       {
93127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93128       };
93129     }
93130   }
93131
93132 }
93133
93134
93135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93136   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93137   int arg2 ;
93138   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93139
93140   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93141   arg2 = (int)jarg2;
93142   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93143   if (!arg3) {
93144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93145     return ;
93146   }
93147   {
93148     try {
93149       try {
93150         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);
93151       }
93152       catch(std::out_of_range &_e) {
93153         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93154         return ;
93155       }
93156
93157     } catch (std::out_of_range& e) {
93158       {
93159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93160       };
93161     } catch (std::exception& e) {
93162       {
93163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93164       };
93165     } catch (Dali::DaliException e) {
93166       {
93167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93168       };
93169     } catch (...) {
93170       {
93171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93172       };
93173     }
93174   }
93175
93176 }
93177
93178
93179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
93180   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93181
93182   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93183   {
93184     try {
93185       delete arg1;
93186     } catch (std::out_of_range& e) {
93187       {
93188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93189       };
93190     } catch (std::exception& e) {
93191       {
93192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93193       };
93194     } catch (Dali::DaliException e) {
93195       {
93196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93197       };
93198     } catch (...) {
93199       {
93200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93201       };
93202     }
93203   }
93204
93205 }
93206
93207
93208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
93209   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93210
93211   arg1 = (std::vector< Dali::Actor > *)jarg1;
93212   {
93213     try {
93214       (arg1)->clear();
93215     } catch (std::out_of_range& e) {
93216       {
93217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93218       };
93219     } catch (std::exception& e) {
93220       {
93221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93222       };
93223     } catch (Dali::DaliException e) {
93224       {
93225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93226       };
93227     } catch (...) {
93228       {
93229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93230       };
93231     }
93232   }
93233
93234 }
93235
93236
93237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
93238   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93239   Dali::Actor *arg2 = 0 ;
93240
93241   arg1 = (std::vector< Dali::Actor > *)jarg1;
93242   arg2 = (Dali::Actor *)jarg2;
93243   if (!arg2) {
93244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93245     return ;
93246   }
93247   {
93248     try {
93249       (arg1)->push_back((Dali::Actor const &)*arg2);
93250     } catch (std::out_of_range& e) {
93251       {
93252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93253       };
93254     } catch (std::exception& e) {
93255       {
93256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93257       };
93258     } catch (Dali::DaliException e) {
93259       {
93260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93261       };
93262     } catch (...) {
93263       {
93264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93265       };
93266     }
93267   }
93268
93269 }
93270
93271
93272 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
93273   unsigned long jresult ;
93274   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93275   std::vector< Dali::Actor >::size_type result;
93276
93277   arg1 = (std::vector< Dali::Actor > *)jarg1;
93278   {
93279     try {
93280       result = ((std::vector< Dali::Actor > const *)arg1)->size();
93281     } catch (std::out_of_range& e) {
93282       {
93283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93284       };
93285     } catch (std::exception& e) {
93286       {
93287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93288       };
93289     } catch (Dali::DaliException e) {
93290       {
93291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93292       };
93293     } catch (...) {
93294       {
93295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93296       };
93297     }
93298   }
93299
93300   jresult = (unsigned long)result;
93301   return jresult;
93302 }
93303
93304
93305 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
93306   unsigned long jresult ;
93307   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93308   std::vector< Dali::Actor >::size_type result;
93309
93310   arg1 = (std::vector< Dali::Actor > *)jarg1;
93311   {
93312     try {
93313       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
93314     } catch (std::out_of_range& e) {
93315       {
93316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93317       };
93318     } catch (std::exception& e) {
93319       {
93320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93321       };
93322     } catch (Dali::DaliException e) {
93323       {
93324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93325       };
93326     } catch (...) {
93327       {
93328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93329       };
93330     }
93331   }
93332
93333   jresult = (unsigned long)result;
93334   return jresult;
93335 }
93336
93337
93338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
93339   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93340   std::vector< Dali::Actor >::size_type arg2 ;
93341
93342   arg1 = (std::vector< Dali::Actor > *)jarg1;
93343   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
93344   {
93345     try {
93346       (arg1)->reserve(arg2);
93347     } catch (std::out_of_range& e) {
93348       {
93349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93350       };
93351     } catch (std::exception& e) {
93352       {
93353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93354       };
93355     } catch (Dali::DaliException e) {
93356       {
93357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93358       };
93359     } catch (...) {
93360       {
93361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93362       };
93363     }
93364   }
93365
93366 }
93367
93368
93369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
93370   void * jresult ;
93371   std::vector< Dali::Actor > *result = 0 ;
93372
93373   {
93374     try {
93375       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
93376     } catch (std::out_of_range& e) {
93377       {
93378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93379       };
93380     } catch (std::exception& e) {
93381       {
93382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93383       };
93384     } catch (Dali::DaliException e) {
93385       {
93386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93387       };
93388     } catch (...) {
93389       {
93390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93391       };
93392     }
93393   }
93394
93395   jresult = (void *)result;
93396   return jresult;
93397 }
93398
93399
93400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
93401   void * jresult ;
93402   std::vector< Dali::Actor > *arg1 = 0 ;
93403   std::vector< Dali::Actor > *result = 0 ;
93404
93405   arg1 = (std::vector< Dali::Actor > *)jarg1;
93406   if (!arg1) {
93407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93408     return 0;
93409   }
93410   {
93411     try {
93412       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
93413     } catch (std::out_of_range& e) {
93414       {
93415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93416       };
93417     } catch (std::exception& e) {
93418       {
93419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93420       };
93421     } catch (Dali::DaliException e) {
93422       {
93423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93424       };
93425     } catch (...) {
93426       {
93427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93428       };
93429     }
93430   }
93431
93432   jresult = (void *)result;
93433   return jresult;
93434 }
93435
93436
93437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
93438   void * jresult ;
93439   int arg1 ;
93440   std::vector< Dali::Actor > *result = 0 ;
93441
93442   arg1 = (int)jarg1;
93443   {
93444     try {
93445       try {
93446         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
93447       }
93448       catch(std::out_of_range &_e) {
93449         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93450         return 0;
93451       }
93452
93453     } catch (std::out_of_range& e) {
93454       {
93455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93456       };
93457     } catch (std::exception& e) {
93458       {
93459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93460       };
93461     } catch (Dali::DaliException e) {
93462       {
93463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93464       };
93465     } catch (...) {
93466       {
93467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93468       };
93469     }
93470   }
93471
93472   jresult = (void *)result;
93473   return jresult;
93474 }
93475
93476
93477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
93478   void * jresult ;
93479   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93480   int arg2 ;
93481   Dali::Actor result;
93482
93483   arg1 = (std::vector< Dali::Actor > *)jarg1;
93484   arg2 = (int)jarg2;
93485   {
93486     try {
93487       try {
93488         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
93489       }
93490       catch(std::out_of_range &_e) {
93491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93492         return 0;
93493       }
93494
93495     } catch (std::out_of_range& e) {
93496       {
93497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93498       };
93499     } catch (std::exception& e) {
93500       {
93501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93502       };
93503     } catch (Dali::DaliException e) {
93504       {
93505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93506       };
93507     } catch (...) {
93508       {
93509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93510       };
93511     }
93512   }
93513
93514   jresult = new Dali::Actor((const Dali::Actor &)result);
93515   return jresult;
93516 }
93517
93518
93519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
93520   void * jresult ;
93521   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93522   int arg2 ;
93523   Dali::Actor *result = 0 ;
93524
93525   arg1 = (std::vector< Dali::Actor > *)jarg1;
93526   arg2 = (int)jarg2;
93527   {
93528     try {
93529       try {
93530         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
93531       }
93532       catch(std::out_of_range &_e) {
93533         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93534         return 0;
93535       }
93536
93537     } catch (std::out_of_range& e) {
93538       {
93539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93540       };
93541     } catch (std::exception& e) {
93542       {
93543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93544       };
93545     } catch (Dali::DaliException e) {
93546       {
93547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93548       };
93549     } catch (...) {
93550       {
93551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93552       };
93553     }
93554   }
93555
93556   jresult = (void *)result;
93557   return jresult;
93558 }
93559
93560
93561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93562   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93563   int arg2 ;
93564   Dali::Actor *arg3 = 0 ;
93565
93566   arg1 = (std::vector< Dali::Actor > *)jarg1;
93567   arg2 = (int)jarg2;
93568   arg3 = (Dali::Actor *)jarg3;
93569   if (!arg3) {
93570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93571     return ;
93572   }
93573   {
93574     try {
93575       try {
93576         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
93577       }
93578       catch(std::out_of_range &_e) {
93579         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93580         return ;
93581       }
93582
93583     } catch (std::out_of_range& e) {
93584       {
93585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93586       };
93587     } catch (std::exception& e) {
93588       {
93589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93590       };
93591     } catch (Dali::DaliException e) {
93592       {
93593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93594       };
93595     } catch (...) {
93596       {
93597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93598       };
93599     }
93600   }
93601
93602 }
93603
93604
93605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
93606   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93607   std::vector< Dali::Actor > *arg2 = 0 ;
93608
93609   arg1 = (std::vector< Dali::Actor > *)jarg1;
93610   arg2 = (std::vector< Dali::Actor > *)jarg2;
93611   if (!arg2) {
93612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93613     return ;
93614   }
93615   {
93616     try {
93617       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
93618     } catch (std::out_of_range& e) {
93619       {
93620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93621       };
93622     } catch (std::exception& e) {
93623       {
93624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93625       };
93626     } catch (Dali::DaliException e) {
93627       {
93628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93629       };
93630     } catch (...) {
93631       {
93632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93633       };
93634     }
93635   }
93636
93637 }
93638
93639
93640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93641   void * jresult ;
93642   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93643   int arg2 ;
93644   int arg3 ;
93645   std::vector< Dali::Actor > *result = 0 ;
93646
93647   arg1 = (std::vector< Dali::Actor > *)jarg1;
93648   arg2 = (int)jarg2;
93649   arg3 = (int)jarg3;
93650   {
93651     try {
93652       try {
93653         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
93654       }
93655       catch(std::out_of_range &_e) {
93656         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93657         return 0;
93658       }
93659       catch(std::invalid_argument &_e) {
93660         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93661         return 0;
93662       }
93663
93664     } catch (std::out_of_range& e) {
93665       {
93666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93667       };
93668     } catch (std::exception& e) {
93669       {
93670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93671       };
93672     } catch (Dali::DaliException e) {
93673       {
93674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93675       };
93676     } catch (...) {
93677       {
93678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93679       };
93680     }
93681   }
93682
93683   jresult = (void *)result;
93684   return jresult;
93685 }
93686
93687
93688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93689   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93690   int arg2 ;
93691   Dali::Actor *arg3 = 0 ;
93692
93693   arg1 = (std::vector< Dali::Actor > *)jarg1;
93694   arg2 = (int)jarg2;
93695   arg3 = (Dali::Actor *)jarg3;
93696   if (!arg3) {
93697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93698     return ;
93699   }
93700   {
93701     try {
93702       try {
93703         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
93704       }
93705       catch(std::out_of_range &_e) {
93706         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93707         return ;
93708       }
93709
93710     } catch (std::out_of_range& e) {
93711       {
93712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93713       };
93714     } catch (std::exception& e) {
93715       {
93716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93717       };
93718     } catch (Dali::DaliException e) {
93719       {
93720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93721       };
93722     } catch (...) {
93723       {
93724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93725       };
93726     }
93727   }
93728
93729 }
93730
93731
93732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93733   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93734   int arg2 ;
93735   std::vector< Dali::Actor > *arg3 = 0 ;
93736
93737   arg1 = (std::vector< Dali::Actor > *)jarg1;
93738   arg2 = (int)jarg2;
93739   arg3 = (std::vector< Dali::Actor > *)jarg3;
93740   if (!arg3) {
93741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93742     return ;
93743   }
93744   {
93745     try {
93746       try {
93747         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93748       }
93749       catch(std::out_of_range &_e) {
93750         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93751         return ;
93752       }
93753
93754     } catch (std::out_of_range& e) {
93755       {
93756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93757       };
93758     } catch (std::exception& e) {
93759       {
93760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93761       };
93762     } catch (Dali::DaliException e) {
93763       {
93764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93765       };
93766     } catch (...) {
93767       {
93768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93769       };
93770     }
93771   }
93772
93773 }
93774
93775
93776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
93777   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93778   int arg2 ;
93779
93780   arg1 = (std::vector< Dali::Actor > *)jarg1;
93781   arg2 = (int)jarg2;
93782   {
93783     try {
93784       try {
93785         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
93786       }
93787       catch(std::out_of_range &_e) {
93788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93789         return ;
93790       }
93791
93792     } catch (std::out_of_range& e) {
93793       {
93794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93795       };
93796     } catch (std::exception& e) {
93797       {
93798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93799       };
93800     } catch (Dali::DaliException e) {
93801       {
93802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93803       };
93804     } catch (...) {
93805       {
93806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93807       };
93808     }
93809   }
93810
93811 }
93812
93813
93814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93815   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93816   int arg2 ;
93817   int arg3 ;
93818
93819   arg1 = (std::vector< Dali::Actor > *)jarg1;
93820   arg2 = (int)jarg2;
93821   arg3 = (int)jarg3;
93822   {
93823     try {
93824       try {
93825         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
93826       }
93827       catch(std::out_of_range &_e) {
93828         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93829         return ;
93830       }
93831       catch(std::invalid_argument &_e) {
93832         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93833         return ;
93834       }
93835
93836     } catch (std::out_of_range& e) {
93837       {
93838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93839       };
93840     } catch (std::exception& e) {
93841       {
93842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93843       };
93844     } catch (Dali::DaliException e) {
93845       {
93846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93847       };
93848     } catch (...) {
93849       {
93850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93851       };
93852     }
93853   }
93854
93855 }
93856
93857
93858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
93859   void * jresult ;
93860   Dali::Actor *arg1 = 0 ;
93861   int arg2 ;
93862   std::vector< Dali::Actor > *result = 0 ;
93863
93864   arg1 = (Dali::Actor *)jarg1;
93865   if (!arg1) {
93866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
93867     return 0;
93868   }
93869   arg2 = (int)jarg2;
93870   {
93871     try {
93872       try {
93873         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
93874       }
93875       catch(std::out_of_range &_e) {
93876         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93877         return 0;
93878       }
93879
93880     } catch (std::out_of_range& e) {
93881       {
93882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93883       };
93884     } catch (std::exception& e) {
93885       {
93886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93887       };
93888     } catch (Dali::DaliException e) {
93889       {
93890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93891       };
93892     } catch (...) {
93893       {
93894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93895       };
93896     }
93897   }
93898
93899   jresult = (void *)result;
93900   return jresult;
93901 }
93902
93903
93904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
93905   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93906
93907   arg1 = (std::vector< Dali::Actor > *)jarg1;
93908   {
93909     try {
93910       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
93911     } catch (std::out_of_range& e) {
93912       {
93913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93914       };
93915     } catch (std::exception& e) {
93916       {
93917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93918       };
93919     } catch (Dali::DaliException e) {
93920       {
93921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93922       };
93923     } catch (...) {
93924       {
93925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93926       };
93927     }
93928   }
93929
93930 }
93931
93932
93933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93934   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93935   int arg2 ;
93936   int arg3 ;
93937
93938   arg1 = (std::vector< Dali::Actor > *)jarg1;
93939   arg2 = (int)jarg2;
93940   arg3 = (int)jarg3;
93941   {
93942     try {
93943       try {
93944         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93945       }
93946       catch(std::out_of_range &_e) {
93947         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93948         return ;
93949       }
93950       catch(std::invalid_argument &_e) {
93951         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93952         return ;
93953       }
93954
93955     } catch (std::out_of_range& e) {
93956       {
93957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93958       };
93959     } catch (std::exception& e) {
93960       {
93961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93962       };
93963     } catch (Dali::DaliException e) {
93964       {
93965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93966       };
93967     } catch (...) {
93968       {
93969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93970       };
93971     }
93972   }
93973
93974 }
93975
93976
93977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93978   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
93979   int arg2 ;
93980   std::vector< Dali::Actor > *arg3 = 0 ;
93981
93982   arg1 = (std::vector< Dali::Actor > *)jarg1;
93983   arg2 = (int)jarg2;
93984   arg3 = (std::vector< Dali::Actor > *)jarg3;
93985   if (!arg3) {
93986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
93987     return ;
93988   }
93989   {
93990     try {
93991       try {
93992         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
93993       }
93994       catch(std::out_of_range &_e) {
93995         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93996         return ;
93997       }
93998
93999     } catch (std::out_of_range& e) {
94000       {
94001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94002       };
94003     } catch (std::exception& e) {
94004       {
94005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94006       };
94007     } catch (Dali::DaliException e) {
94008       {
94009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94010       };
94011     } catch (...) {
94012       {
94013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94014       };
94015     }
94016   }
94017
94018 }
94019
94020
94021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94022   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94023
94024   arg1 = (std::vector< Dali::Actor > *)jarg1;
94025   {
94026     try {
94027       delete arg1;
94028     } catch (std::out_of_range& e) {
94029       {
94030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94031       };
94032     } catch (std::exception& e) {
94033       {
94034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94035       };
94036     } catch (Dali::DaliException e) {
94037       {
94038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94039       };
94040     } catch (...) {
94041       {
94042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94043       };
94044     }
94045   }
94046
94047 }
94048
94049
94050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94051   unsigned int jresult ;
94052   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94053   bool result;
94054
94055   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94056   {
94057     try {
94058       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94059     } catch (std::out_of_range& e) {
94060       {
94061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94062       };
94063     } catch (std::exception& e) {
94064       {
94065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94066       };
94067     } catch (Dali::DaliException e) {
94068       {
94069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94070       };
94071     } catch (...) {
94072       {
94073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94074       };
94075     }
94076   }
94077
94078   jresult = result;
94079   return jresult;
94080 }
94081
94082
94083 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
94084   unsigned long jresult ;
94085   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94086   std::size_t result;
94087
94088   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94089   {
94090     try {
94091       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94092     } catch (std::out_of_range& e) {
94093       {
94094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94095       };
94096     } catch (std::exception& e) {
94097       {
94098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94099       };
94100     } catch (Dali::DaliException e) {
94101       {
94102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94103       };
94104     } catch (...) {
94105       {
94106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94107       };
94108     }
94109   }
94110
94111   jresult = (unsigned long)result;
94112   return jresult;
94113 }
94114
94115
94116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
94117   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94118   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94119
94120   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94121   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94122   {
94123     try {
94124       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
94125     } catch (std::out_of_range& e) {
94126       {
94127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94128       };
94129     } catch (std::exception& e) {
94130       {
94131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94132       };
94133     } catch (Dali::DaliException e) {
94134       {
94135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94136       };
94137     } catch (...) {
94138       {
94139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94140       };
94141     }
94142   }
94143
94144 }
94145
94146
94147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
94148   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94149   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
94150
94151   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94152   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
94153   {
94154     try {
94155       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
94156     } catch (std::out_of_range& e) {
94157       {
94158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94159       };
94160     } catch (std::exception& e) {
94161       {
94162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94163       };
94164     } catch (Dali::DaliException e) {
94165       {
94166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94167       };
94168     } catch (...) {
94169       {
94170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94171       };
94172     }
94173   }
94174
94175 }
94176
94177
94178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
94179   unsigned int jresult ;
94180   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94181   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
94182   bool result;
94183
94184   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94185   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
94186   if (!arg2) {
94187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
94188     return 0;
94189   }
94190   {
94191     try {
94192       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
94193     } catch (std::out_of_range& e) {
94194       {
94195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94196       };
94197     } catch (std::exception& e) {
94198       {
94199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94200       };
94201     } catch (Dali::DaliException e) {
94202       {
94203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94204       };
94205     } catch (...) {
94206       {
94207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94208       };
94209     }
94210   }
94211
94212   jresult = result;
94213   return jresult;
94214 }
94215
94216
94217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
94218   void * jresult ;
94219   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
94220
94221   {
94222     try {
94223       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
94224     } catch (std::out_of_range& e) {
94225       {
94226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94227       };
94228     } catch (std::exception& e) {
94229       {
94230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94231       };
94232     } catch (Dali::DaliException e) {
94233       {
94234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94235       };
94236     } catch (...) {
94237       {
94238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94239       };
94240     }
94241   }
94242
94243   jresult = (void *)result;
94244   return jresult;
94245 }
94246
94247
94248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
94249   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94250
94251   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94252   {
94253     try {
94254       delete arg1;
94255     } catch (std::out_of_range& e) {
94256       {
94257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94258       };
94259     } catch (std::exception& e) {
94260       {
94261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94262       };
94263     } catch (Dali::DaliException e) {
94264       {
94265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94266       };
94267     } catch (...) {
94268       {
94269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94270       };
94271     }
94272   }
94273
94274 }
94275
94276
94277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
94278   unsigned int jresult ;
94279   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94280   bool result;
94281
94282   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94283   {
94284     try {
94285       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);
94286     } catch (std::out_of_range& e) {
94287       {
94288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94289       };
94290     } catch (std::exception& e) {
94291       {
94292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94293       };
94294     } catch (Dali::DaliException e) {
94295       {
94296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94297       };
94298     } catch (...) {
94299       {
94300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94301       };
94302     }
94303   }
94304
94305   jresult = result;
94306   return jresult;
94307 }
94308
94309
94310 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
94311   unsigned long jresult ;
94312   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94313   std::size_t result;
94314
94315   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94316   {
94317     try {
94318       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);
94319     } catch (std::out_of_range& e) {
94320       {
94321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94322       };
94323     } catch (std::exception& e) {
94324       {
94325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94326       };
94327     } catch (Dali::DaliException e) {
94328       {
94329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94330       };
94331     } catch (...) {
94332       {
94333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94334       };
94335     }
94336   }
94337
94338   jresult = (unsigned long)result;
94339   return jresult;
94340 }
94341
94342
94343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
94344   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94345   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94346
94347   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94348   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94349   {
94350     try {
94351       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
94352     } catch (std::out_of_range& e) {
94353       {
94354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94355       };
94356     } catch (std::exception& e) {
94357       {
94358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94359       };
94360     } catch (Dali::DaliException e) {
94361       {
94362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94363       };
94364     } catch (...) {
94365       {
94366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94367       };
94368     }
94369   }
94370
94371 }
94372
94373
94374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
94375   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94376   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
94377
94378   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94379   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
94380   {
94381     try {
94382       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
94383     } catch (std::out_of_range& e) {
94384       {
94385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94386       };
94387     } catch (std::exception& e) {
94388       {
94389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94390       };
94391     } catch (Dali::DaliException e) {
94392       {
94393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94394       };
94395     } catch (...) {
94396       {
94397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94398       };
94399     }
94400   }
94401
94402 }
94403
94404
94405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94406   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94407   Dali::Actor arg2 ;
94408   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
94409   Dali::Actor *argp2 ;
94410
94411   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94412   argp2 = (Dali::Actor *)jarg2;
94413   if (!argp2) {
94414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94415     return ;
94416   }
94417   arg2 = *argp2;
94418   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
94419   {
94420     try {
94421       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
94422     } catch (std::out_of_range& e) {
94423       {
94424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94425       };
94426     } catch (std::exception& e) {
94427       {
94428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94429       };
94430     } catch (Dali::DaliException e) {
94431       {
94432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94433       };
94434     } catch (...) {
94435       {
94436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94437       };
94438     }
94439   }
94440
94441 }
94442
94443
94444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
94445   void * jresult ;
94446   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
94447
94448   {
94449     try {
94450       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
94451     } catch (std::out_of_range& e) {
94452       {
94453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94454       };
94455     } catch (std::exception& e) {
94456       {
94457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94458       };
94459     } catch (Dali::DaliException e) {
94460       {
94461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94462       };
94463     } catch (...) {
94464       {
94465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94466       };
94467     }
94468   }
94469
94470   jresult = (void *)result;
94471   return jresult;
94472 }
94473
94474
94475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
94476   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
94477
94478   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
94479   {
94480     try {
94481       delete arg1;
94482     } catch (std::out_of_range& e) {
94483       {
94484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94485       };
94486     } catch (std::exception& e) {
94487       {
94488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94489       };
94490     } catch (Dali::DaliException e) {
94491       {
94492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94493       };
94494     } catch (...) {
94495       {
94496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94497       };
94498     }
94499   }
94500
94501 }
94502
94503
94504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
94505   unsigned int jresult ;
94506   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94507   bool result;
94508
94509   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94510   {
94511     try {
94512       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94513     } catch (std::out_of_range& e) {
94514       {
94515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94516       };
94517     } catch (std::exception& e) {
94518       {
94519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94520       };
94521     } catch (Dali::DaliException e) {
94522       {
94523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94524       };
94525     } catch (...) {
94526       {
94527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94528       };
94529     }
94530   }
94531
94532   jresult = result;
94533   return jresult;
94534 }
94535
94536
94537 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
94538   unsigned long jresult ;
94539   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94540   std::size_t result;
94541
94542   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94543   {
94544     try {
94545       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
94546     } catch (std::out_of_range& e) {
94547       {
94548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94549       };
94550     } catch (std::exception& e) {
94551       {
94552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94553       };
94554     } catch (Dali::DaliException e) {
94555       {
94556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94557       };
94558     } catch (...) {
94559       {
94560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94561       };
94562     }
94563   }
94564
94565   jresult = (unsigned long)result;
94566   return jresult;
94567 }
94568
94569
94570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
94571   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94572   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94573
94574   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94575   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94576   {
94577     try {
94578       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
94579     } catch (std::out_of_range& e) {
94580       {
94581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94582       };
94583     } catch (std::exception& e) {
94584       {
94585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94586       };
94587     } catch (Dali::DaliException e) {
94588       {
94589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94590       };
94591     } catch (...) {
94592       {
94593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94594       };
94595     }
94596   }
94597
94598 }
94599
94600
94601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94602   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94603   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
94604
94605   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94606   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
94607   {
94608     try {
94609       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
94610     } catch (std::out_of_range& e) {
94611       {
94612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94613       };
94614     } catch (std::exception& e) {
94615       {
94616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94617       };
94618     } catch (Dali::DaliException e) {
94619       {
94620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94621       };
94622     } catch (...) {
94623       {
94624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94625       };
94626     }
94627   }
94628
94629 }
94630
94631
94632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
94633   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94634   Dali::Actor arg2 ;
94635   Dali::Actor arg3 ;
94636   Dali::Actor *argp2 ;
94637   Dali::Actor *argp3 ;
94638
94639   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94640   argp2 = (Dali::Actor *)jarg2;
94641   if (!argp2) {
94642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94643     return ;
94644   }
94645   arg2 = *argp2;
94646   argp3 = (Dali::Actor *)jarg3;
94647   if (!argp3) {
94648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94649     return ;
94650   }
94651   arg3 = *argp3;
94652   {
94653     try {
94654       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
94655     } catch (std::out_of_range& e) {
94656       {
94657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94658       };
94659     } catch (std::exception& e) {
94660       {
94661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94662       };
94663     } catch (Dali::DaliException e) {
94664       {
94665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94666       };
94667     } catch (...) {
94668       {
94669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94670       };
94671     }
94672   }
94673
94674 }
94675
94676
94677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
94678   void * jresult ;
94679   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
94680
94681   {
94682     try {
94683       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
94684     } catch (std::out_of_range& e) {
94685       {
94686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94687       };
94688     } catch (std::exception& e) {
94689       {
94690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94691       };
94692     } catch (Dali::DaliException e) {
94693       {
94694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94695       };
94696     } catch (...) {
94697       {
94698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94699       };
94700     }
94701   }
94702
94703   jresult = (void *)result;
94704   return jresult;
94705 }
94706
94707
94708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
94709   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
94710
94711   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
94712   {
94713     try {
94714       delete arg1;
94715     } catch (std::out_of_range& e) {
94716       {
94717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94718       };
94719     } catch (std::exception& e) {
94720       {
94721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94722       };
94723     } catch (Dali::DaliException e) {
94724       {
94725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94726       };
94727     } catch (...) {
94728       {
94729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94730       };
94731     }
94732   }
94733
94734 }
94735
94736
94737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
94738   unsigned int jresult ;
94739   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94740   bool result;
94741
94742   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94743   {
94744     try {
94745       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94746     } catch (std::out_of_range& e) {
94747       {
94748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94749       };
94750     } catch (std::exception& e) {
94751       {
94752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94753       };
94754     } catch (Dali::DaliException e) {
94755       {
94756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94757       };
94758     } catch (...) {
94759       {
94760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94761       };
94762     }
94763   }
94764
94765   jresult = result;
94766   return jresult;
94767 }
94768
94769
94770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
94771   unsigned long jresult ;
94772   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94773   std::size_t result;
94774
94775   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94776   {
94777     try {
94778       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
94779     } catch (std::out_of_range& e) {
94780       {
94781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94782       };
94783     } catch (std::exception& e) {
94784       {
94785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94786       };
94787     } catch (Dali::DaliException e) {
94788       {
94789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94790       };
94791     } catch (...) {
94792       {
94793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94794       };
94795     }
94796   }
94797
94798   jresult = (unsigned long)result;
94799   return jresult;
94800 }
94801
94802
94803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
94804   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94805   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94806
94807   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94808   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94809   {
94810     try {
94811       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
94812     } catch (std::out_of_range& e) {
94813       {
94814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94815       };
94816     } catch (std::exception& e) {
94817       {
94818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94819       };
94820     } catch (Dali::DaliException e) {
94821       {
94822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94823       };
94824     } catch (...) {
94825       {
94826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94827       };
94828     }
94829   }
94830
94831 }
94832
94833
94834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
94835   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94836   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
94837
94838   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94839   arg2 = (void (*)(Dali::Actor,bool))jarg2;
94840   {
94841     try {
94842       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
94843     } catch (std::out_of_range& e) {
94844       {
94845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94846       };
94847     } catch (std::exception& e) {
94848       {
94849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94850       };
94851     } catch (Dali::DaliException e) {
94852       {
94853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94854       };
94855     } catch (...) {
94856       {
94857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94858       };
94859     }
94860   }
94861
94862 }
94863
94864
94865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
94866   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94867   Dali::Actor arg2 ;
94868   bool arg3 ;
94869   Dali::Actor *argp2 ;
94870
94871   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94872   argp2 = (Dali::Actor *)jarg2;
94873   if (!argp2) {
94874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94875     return ;
94876   }
94877   arg2 = *argp2;
94878   arg3 = jarg3 ? true : false;
94879   {
94880     try {
94881       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
94882     } catch (std::out_of_range& e) {
94883       {
94884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94885       };
94886     } catch (std::exception& e) {
94887       {
94888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94889       };
94890     } catch (Dali::DaliException e) {
94891       {
94892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94893       };
94894     } catch (...) {
94895       {
94896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94897       };
94898     }
94899   }
94900
94901 }
94902
94903
94904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
94905   void * jresult ;
94906   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
94907
94908   {
94909     try {
94910       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
94911     } catch (std::out_of_range& e) {
94912       {
94913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94914       };
94915     } catch (std::exception& e) {
94916       {
94917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94918       };
94919     } catch (Dali::DaliException e) {
94920       {
94921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94922       };
94923     } catch (...) {
94924       {
94925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94926       };
94927     }
94928   }
94929
94930   jresult = (void *)result;
94931   return jresult;
94932 }
94933
94934
94935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
94936   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
94937
94938   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
94939   {
94940     try {
94941       delete arg1;
94942     } catch (std::out_of_range& e) {
94943       {
94944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94945       };
94946     } catch (std::exception& e) {
94947       {
94948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94949       };
94950     } catch (Dali::DaliException e) {
94951       {
94952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94953       };
94954     } catch (...) {
94955       {
94956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94957       };
94958     }
94959   }
94960
94961 }
94962
94963
94964 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
94965   unsigned int jresult ;
94966   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
94967   bool result;
94968
94969   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
94970   {
94971     try {
94972       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);
94973     } catch (std::out_of_range& e) {
94974       {
94975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94976       };
94977     } catch (std::exception& e) {
94978       {
94979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94980       };
94981     } catch (Dali::DaliException e) {
94982       {
94983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94984       };
94985     } catch (...) {
94986       {
94987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94988       };
94989     }
94990   }
94991
94992   jresult = result;
94993   return jresult;
94994 }
94995
94996
94997 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
94998   unsigned long jresult ;
94999   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95000   std::size_t result;
95001
95002   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95003   {
95004     try {
95005       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);
95006     } catch (std::out_of_range& e) {
95007       {
95008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95009       };
95010     } catch (std::exception& e) {
95011       {
95012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95013       };
95014     } catch (Dali::DaliException e) {
95015       {
95016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95017       };
95018     } catch (...) {
95019       {
95020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95021       };
95022     }
95023   }
95024
95025   jresult = (unsigned long)result;
95026   return jresult;
95027 }
95028
95029
95030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95031   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95032   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95033
95034   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95035   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95036   {
95037     try {
95038       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95039     } catch (std::out_of_range& e) {
95040       {
95041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95042       };
95043     } catch (std::exception& e) {
95044       {
95045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95046       };
95047     } catch (Dali::DaliException e) {
95048       {
95049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95050       };
95051     } catch (...) {
95052       {
95053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95054       };
95055     }
95056   }
95057
95058 }
95059
95060
95061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95062   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95063   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95064
95065   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95066   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95067   {
95068     try {
95069       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
95070     } catch (std::out_of_range& e) {
95071       {
95072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95073       };
95074     } catch (std::exception& e) {
95075       {
95076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95077       };
95078     } catch (Dali::DaliException e) {
95079       {
95080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95081       };
95082     } catch (...) {
95083       {
95084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95085       };
95086     }
95087   }
95088
95089 }
95090
95091
95092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95093   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95094   Dali::Toolkit::StyleManager arg2 ;
95095   Dali::StyleChange::Type arg3 ;
95096   Dali::Toolkit::StyleManager *argp2 ;
95097
95098   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95099   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
95100   if (!argp2) {
95101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
95102     return ;
95103   }
95104   arg2 = *argp2;
95105   arg3 = (Dali::StyleChange::Type)jarg3;
95106   {
95107     try {
95108       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
95109     } catch (std::out_of_range& e) {
95110       {
95111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95112       };
95113     } catch (std::exception& e) {
95114       {
95115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95116       };
95117     } catch (Dali::DaliException e) {
95118       {
95119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95120       };
95121     } catch (...) {
95122       {
95123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95124       };
95125     }
95126   }
95127
95128 }
95129
95130
95131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
95132   void * jresult ;
95133   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
95134
95135   {
95136     try {
95137       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
95138     } catch (std::out_of_range& e) {
95139       {
95140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95141       };
95142     } catch (std::exception& e) {
95143       {
95144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95145       };
95146     } catch (Dali::DaliException e) {
95147       {
95148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95149       };
95150     } catch (...) {
95151       {
95152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95153       };
95154     }
95155   }
95156
95157   jresult = (void *)result;
95158   return jresult;
95159 }
95160
95161
95162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
95163   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95164
95165   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95166   {
95167     try {
95168       delete arg1;
95169     } catch (std::out_of_range& e) {
95170       {
95171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95172       };
95173     } catch (std::exception& e) {
95174       {
95175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95176       };
95177     } catch (Dali::DaliException e) {
95178       {
95179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95180       };
95181     } catch (...) {
95182       {
95183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95184       };
95185     }
95186   }
95187
95188 }
95189
95190
95191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
95192   unsigned int jresult ;
95193   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95194   bool result;
95195
95196   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95197   {
95198     try {
95199       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95200     } catch (std::out_of_range& e) {
95201       {
95202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95203       };
95204     } catch (std::exception& e) {
95205       {
95206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95207       };
95208     } catch (Dali::DaliException e) {
95209       {
95210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95211       };
95212     } catch (...) {
95213       {
95214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95215       };
95216     }
95217   }
95218
95219   jresult = result;
95220   return jresult;
95221 }
95222
95223
95224 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
95225   unsigned long jresult ;
95226   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95227   std::size_t result;
95228
95229   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95230   {
95231     try {
95232       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
95233     } catch (std::out_of_range& e) {
95234       {
95235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95236       };
95237     } catch (std::exception& e) {
95238       {
95239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95240       };
95241     } catch (Dali::DaliException e) {
95242       {
95243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95244       };
95245     } catch (...) {
95246       {
95247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95248       };
95249     }
95250   }
95251
95252   jresult = (unsigned long)result;
95253   return jresult;
95254 }
95255
95256
95257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
95258   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95259   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95260
95261   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95262   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95263   {
95264     try {
95265       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
95266     } catch (std::out_of_range& e) {
95267       {
95268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95269       };
95270     } catch (std::exception& e) {
95271       {
95272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95273       };
95274     } catch (Dali::DaliException e) {
95275       {
95276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95277       };
95278     } catch (...) {
95279       {
95280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95281       };
95282     }
95283   }
95284
95285 }
95286
95287
95288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
95289   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95290   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
95291
95292   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95293   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
95294   {
95295     try {
95296       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
95297     } catch (std::out_of_range& e) {
95298       {
95299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95300       };
95301     } catch (std::exception& e) {
95302       {
95303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95304       };
95305     } catch (Dali::DaliException e) {
95306       {
95307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95308       };
95309     } catch (...) {
95310       {
95311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95312       };
95313     }
95314   }
95315
95316 }
95317
95318
95319 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
95320   unsigned int jresult ;
95321   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95322   Dali::Toolkit::Button arg2 ;
95323   Dali::Toolkit::Button *argp2 ;
95324   bool result;
95325
95326   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95327   argp2 = (Dali::Toolkit::Button *)jarg2;
95328   if (!argp2) {
95329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
95330     return 0;
95331   }
95332   arg2 = *argp2;
95333   {
95334     try {
95335       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
95336     } catch (std::out_of_range& e) {
95337       {
95338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95339       };
95340     } catch (std::exception& e) {
95341       {
95342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95343       };
95344     } catch (Dali::DaliException e) {
95345       {
95346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95347       };
95348     } catch (...) {
95349       {
95350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95351       };
95352     }
95353   }
95354
95355   jresult = result;
95356   return jresult;
95357 }
95358
95359
95360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
95361   void * jresult ;
95362   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
95363
95364   {
95365     try {
95366       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
95367     } catch (std::out_of_range& e) {
95368       {
95369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95370       };
95371     } catch (std::exception& e) {
95372       {
95373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95374       };
95375     } catch (Dali::DaliException e) {
95376       {
95377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95378       };
95379     } catch (...) {
95380       {
95381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95382       };
95383     }
95384   }
95385
95386   jresult = (void *)result;
95387   return jresult;
95388 }
95389
95390
95391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
95392   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
95393
95394   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
95395   {
95396     try {
95397       delete arg1;
95398     } catch (std::out_of_range& e) {
95399       {
95400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95401       };
95402     } catch (std::exception& e) {
95403       {
95404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95405       };
95406     } catch (Dali::DaliException e) {
95407       {
95408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95409       };
95410     } catch (...) {
95411       {
95412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95413       };
95414     }
95415   }
95416
95417 }
95418
95419
95420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
95421   unsigned int jresult ;
95422   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95423   bool result;
95424
95425   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95426   {
95427     try {
95428       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95429     } catch (std::out_of_range& e) {
95430       {
95431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95432       };
95433     } catch (std::exception& e) {
95434       {
95435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95436       };
95437     } catch (Dali::DaliException e) {
95438       {
95439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95440       };
95441     } catch (...) {
95442       {
95443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95444       };
95445     }
95446   }
95447
95448   jresult = result;
95449   return jresult;
95450 }
95451
95452
95453 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
95454   unsigned long jresult ;
95455   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95456   std::size_t result;
95457
95458   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95459   {
95460     try {
95461       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
95462     } catch (std::out_of_range& e) {
95463       {
95464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95465       };
95466     } catch (std::exception& e) {
95467       {
95468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95469       };
95470     } catch (Dali::DaliException e) {
95471       {
95472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95473       };
95474     } catch (...) {
95475       {
95476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95477       };
95478     }
95479   }
95480
95481   jresult = (unsigned long)result;
95482   return jresult;
95483 }
95484
95485
95486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
95487   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95488   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95489
95490   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95491   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95492   {
95493     try {
95494       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
95495     } catch (std::out_of_range& e) {
95496       {
95497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95498       };
95499     } catch (std::exception& e) {
95500       {
95501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95502       };
95503     } catch (Dali::DaliException e) {
95504       {
95505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95506       };
95507     } catch (...) {
95508       {
95509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95510       };
95511     }
95512   }
95513
95514 }
95515
95516
95517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
95518   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95519   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
95520
95521   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95522   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
95523   {
95524     try {
95525       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
95526     } catch (std::out_of_range& e) {
95527       {
95528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95529       };
95530     } catch (std::exception& e) {
95531       {
95532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95533       };
95534     } catch (Dali::DaliException e) {
95535       {
95536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95537       };
95538     } catch (...) {
95539       {
95540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95541       };
95542     }
95543   }
95544
95545 }
95546
95547
95548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
95549   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95550   Dali::Toolkit::GaussianBlurView arg2 ;
95551   Dali::Toolkit::GaussianBlurView *argp2 ;
95552
95553   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95554   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
95555   if (!argp2) {
95556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
95557     return ;
95558   }
95559   arg2 = *argp2;
95560   {
95561     try {
95562       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
95563     } catch (std::out_of_range& e) {
95564       {
95565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95566       };
95567     } catch (std::exception& e) {
95568       {
95569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95570       };
95571     } catch (Dali::DaliException e) {
95572       {
95573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95574       };
95575     } catch (...) {
95576       {
95577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95578       };
95579     }
95580   }
95581
95582 }
95583
95584
95585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
95586   void * jresult ;
95587   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
95588
95589   {
95590     try {
95591       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
95592     } catch (std::out_of_range& e) {
95593       {
95594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95595       };
95596     } catch (std::exception& e) {
95597       {
95598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95599       };
95600     } catch (Dali::DaliException e) {
95601       {
95602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95603       };
95604     } catch (...) {
95605       {
95606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95607       };
95608     }
95609   }
95610
95611   jresult = (void *)result;
95612   return jresult;
95613 }
95614
95615
95616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
95617   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
95618
95619   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
95620   {
95621     try {
95622       delete arg1;
95623     } catch (std::out_of_range& e) {
95624       {
95625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95626       };
95627     } catch (std::exception& e) {
95628       {
95629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95630       };
95631     } catch (Dali::DaliException e) {
95632       {
95633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95634       };
95635     } catch (...) {
95636       {
95637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95638       };
95639     }
95640   }
95641
95642 }
95643
95644
95645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
95646   unsigned int jresult ;
95647   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95648   bool result;
95649
95650   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95651   {
95652     try {
95653       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);
95654     } catch (std::out_of_range& e) {
95655       {
95656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95657       };
95658     } catch (std::exception& e) {
95659       {
95660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95661       };
95662     } catch (Dali::DaliException e) {
95663       {
95664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95665       };
95666     } catch (...) {
95667       {
95668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95669       };
95670     }
95671   }
95672
95673   jresult = result;
95674   return jresult;
95675 }
95676
95677
95678 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
95679   unsigned long jresult ;
95680   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95681   std::size_t result;
95682
95683   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95684   {
95685     try {
95686       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);
95687     } catch (std::out_of_range& e) {
95688       {
95689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95690       };
95691     } catch (std::exception& e) {
95692       {
95693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95694       };
95695     } catch (Dali::DaliException e) {
95696       {
95697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95698       };
95699     } catch (...) {
95700       {
95701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95702       };
95703     }
95704   }
95705
95706   jresult = (unsigned long)result;
95707   return jresult;
95708 }
95709
95710
95711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
95712   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95713   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95714
95715   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95716   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95717   {
95718     try {
95719       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
95720     } catch (std::out_of_range& e) {
95721       {
95722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95723       };
95724     } catch (std::exception& e) {
95725       {
95726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95727       };
95728     } catch (Dali::DaliException e) {
95729       {
95730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95731       };
95732     } catch (...) {
95733       {
95734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95735       };
95736     }
95737   }
95738
95739 }
95740
95741
95742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
95743   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95744   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
95745
95746   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95747   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
95748   {
95749     try {
95750       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95751     } catch (std::out_of_range& e) {
95752       {
95753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95754       };
95755     } catch (std::exception& e) {
95756       {
95757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95758       };
95759     } catch (Dali::DaliException e) {
95760       {
95761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95762       };
95763     } catch (...) {
95764       {
95765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95766       };
95767     }
95768   }
95769
95770 }
95771
95772
95773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
95774   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95775   Dali::Toolkit::PageTurnView arg2 ;
95776   unsigned int arg3 ;
95777   bool arg4 ;
95778   Dali::Toolkit::PageTurnView *argp2 ;
95779
95780   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95781   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
95782   if (!argp2) {
95783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
95784     return ;
95785   }
95786   arg2 = *argp2;
95787   arg3 = (unsigned int)jarg3;
95788   arg4 = jarg4 ? true : false;
95789   {
95790     try {
95791       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
95792     } catch (std::out_of_range& e) {
95793       {
95794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95795       };
95796     } catch (std::exception& e) {
95797       {
95798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95799       };
95800     } catch (Dali::DaliException e) {
95801       {
95802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95803       };
95804     } catch (...) {
95805       {
95806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95807       };
95808     }
95809   }
95810
95811 }
95812
95813
95814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
95815   void * jresult ;
95816   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
95817
95818   {
95819     try {
95820       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
95821     } catch (std::out_of_range& e) {
95822       {
95823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95824       };
95825     } catch (std::exception& e) {
95826       {
95827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95828       };
95829     } catch (Dali::DaliException e) {
95830       {
95831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95832       };
95833     } catch (...) {
95834       {
95835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95836       };
95837     }
95838   }
95839
95840   jresult = (void *)result;
95841   return jresult;
95842 }
95843
95844
95845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
95846   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
95847
95848   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
95849   {
95850     try {
95851       delete arg1;
95852     } catch (std::out_of_range& e) {
95853       {
95854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95855       };
95856     } catch (std::exception& e) {
95857       {
95858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95859       };
95860     } catch (Dali::DaliException e) {
95861       {
95862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95863       };
95864     } catch (...) {
95865       {
95866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95867       };
95868     }
95869   }
95870
95871 }
95872
95873
95874 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
95875   unsigned int jresult ;
95876   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95877   bool result;
95878
95879   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95880   {
95881     try {
95882       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
95883     } catch (std::out_of_range& e) {
95884       {
95885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95886       };
95887     } catch (std::exception& e) {
95888       {
95889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95890       };
95891     } catch (Dali::DaliException e) {
95892       {
95893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95894       };
95895     } catch (...) {
95896       {
95897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95898       };
95899     }
95900   }
95901
95902   jresult = result;
95903   return jresult;
95904 }
95905
95906
95907 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
95908   unsigned long jresult ;
95909   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95910   std::size_t result;
95911
95912   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95913   {
95914     try {
95915       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
95916     } catch (std::out_of_range& e) {
95917       {
95918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95919       };
95920     } catch (std::exception& e) {
95921       {
95922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95923       };
95924     } catch (Dali::DaliException e) {
95925       {
95926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95927       };
95928     } catch (...) {
95929       {
95930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95931       };
95932     }
95933   }
95934
95935   jresult = (unsigned long)result;
95936   return jresult;
95937 }
95938
95939
95940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
95941   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95942   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
95943
95944   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95945   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
95946   {
95947     try {
95948       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
95949     } catch (std::out_of_range& e) {
95950       {
95951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95952       };
95953     } catch (std::exception& e) {
95954       {
95955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95956       };
95957     } catch (Dali::DaliException e) {
95958       {
95959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95960       };
95961     } catch (...) {
95962       {
95963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95964       };
95965     }
95966   }
95967
95968 }
95969
95970
95971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
95972   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
95973   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
95974
95975   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
95976   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
95977   {
95978     try {
95979       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
95980     } catch (std::out_of_range& e) {
95981       {
95982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95983       };
95984     } catch (std::exception& e) {
95985       {
95986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95987       };
95988     } catch (Dali::DaliException e) {
95989       {
95990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95991       };
95992     } catch (...) {
95993       {
95994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95995       };
95996     }
95997   }
95998
95999 }
96000
96001
96002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96003   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96004   Dali::Toolkit::PageTurnView arg2 ;
96005   Dali::Toolkit::PageTurnView *argp2 ;
96006
96007   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96008   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96009   if (!argp2) {
96010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96011     return ;
96012   }
96013   arg2 = *argp2;
96014   {
96015     try {
96016       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96017     } catch (std::out_of_range& e) {
96018       {
96019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96020       };
96021     } catch (std::exception& e) {
96022       {
96023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96024       };
96025     } catch (Dali::DaliException e) {
96026       {
96027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96028       };
96029     } catch (...) {
96030       {
96031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96032       };
96033     }
96034   }
96035
96036 }
96037
96038
96039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96040   void * jresult ;
96041   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96042
96043   {
96044     try {
96045       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
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_PagePanSignal(void * jarg1) {
96071   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96072
96073   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)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 unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
96100   unsigned int jresult ;
96101   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96102   bool result;
96103
96104   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96105   {
96106     try {
96107       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);
96108     } catch (std::out_of_range& e) {
96109       {
96110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96111       };
96112     } catch (std::exception& e) {
96113       {
96114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96115       };
96116     } catch (Dali::DaliException e) {
96117       {
96118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96119       };
96120     } catch (...) {
96121       {
96122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96123       };
96124     }
96125   }
96126
96127   jresult = result;
96128   return jresult;
96129 }
96130
96131
96132 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
96133   unsigned long jresult ;
96134   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96135   std::size_t result;
96136
96137   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96138   {
96139     try {
96140       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);
96141     } catch (std::out_of_range& e) {
96142       {
96143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96144       };
96145     } catch (std::exception& e) {
96146       {
96147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96148       };
96149     } catch (Dali::DaliException e) {
96150       {
96151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96152       };
96153     } catch (...) {
96154       {
96155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96156       };
96157     }
96158   }
96159
96160   jresult = (unsigned long)result;
96161   return jresult;
96162 }
96163
96164
96165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
96166   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96167   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96168
96169   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96170   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96171   {
96172     try {
96173       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
96174     } catch (std::out_of_range& e) {
96175       {
96176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96177       };
96178     } catch (std::exception& e) {
96179       {
96180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96181       };
96182     } catch (Dali::DaliException e) {
96183       {
96184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96185       };
96186     } catch (...) {
96187       {
96188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96189       };
96190     }
96191   }
96192
96193 }
96194
96195
96196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96197   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96198   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
96199
96200   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96201   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
96202   {
96203     try {
96204       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
96205     } catch (std::out_of_range& e) {
96206       {
96207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96208       };
96209     } catch (std::exception& e) {
96210       {
96211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96212       };
96213     } catch (Dali::DaliException e) {
96214       {
96215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96216       };
96217     } catch (...) {
96218       {
96219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96220       };
96221     }
96222   }
96223
96224 }
96225
96226
96227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
96228   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96229   Dali::Toolkit::ProgressBar arg2 ;
96230   float arg3 ;
96231   float arg4 ;
96232   Dali::Toolkit::ProgressBar *argp2 ;
96233
96234   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96235   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
96236   if (!argp2) {
96237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
96238     return ;
96239   }
96240   arg2 = *argp2;
96241   arg3 = (float)jarg3;
96242   arg4 = (float)jarg4;
96243   {
96244     try {
96245       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96246     } catch (std::out_of_range& e) {
96247       {
96248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96249       };
96250     } catch (std::exception& e) {
96251       {
96252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96253       };
96254     } catch (Dali::DaliException e) {
96255       {
96256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96257       };
96258     } catch (...) {
96259       {
96260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96261       };
96262     }
96263   }
96264
96265 }
96266
96267
96268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
96269   void * jresult ;
96270   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
96271
96272   {
96273     try {
96274       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
96275     } catch (std::out_of_range& e) {
96276       {
96277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96278       };
96279     } catch (std::exception& e) {
96280       {
96281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96282       };
96283     } catch (Dali::DaliException e) {
96284       {
96285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96286       };
96287     } catch (...) {
96288       {
96289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96290       };
96291     }
96292   }
96293
96294   jresult = (void *)result;
96295   return jresult;
96296 }
96297
96298
96299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
96300   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
96301
96302   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
96303   {
96304     try {
96305       delete arg1;
96306     } catch (std::out_of_range& e) {
96307       {
96308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96309       };
96310     } catch (std::exception& e) {
96311       {
96312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96313       };
96314     } catch (Dali::DaliException e) {
96315       {
96316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96317       };
96318     } catch (...) {
96319       {
96320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96321       };
96322     }
96323   }
96324
96325 }
96326
96327
96328 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
96329   unsigned int jresult ;
96330   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96331   bool result;
96332
96333   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96334   {
96335     try {
96336       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);
96337     } catch (std::out_of_range& e) {
96338       {
96339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96340       };
96341     } catch (std::exception& e) {
96342       {
96343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96344       };
96345     } catch (Dali::DaliException e) {
96346       {
96347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96348       };
96349     } catch (...) {
96350       {
96351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96352       };
96353     }
96354   }
96355
96356   jresult = result;
96357   return jresult;
96358 }
96359
96360
96361 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
96362   unsigned long jresult ;
96363   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96364   std::size_t result;
96365
96366   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96367   {
96368     try {
96369       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);
96370     } catch (std::out_of_range& e) {
96371       {
96372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96373       };
96374     } catch (std::exception& e) {
96375       {
96376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96377       };
96378     } catch (Dali::DaliException e) {
96379       {
96380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96381       };
96382     } catch (...) {
96383       {
96384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96385       };
96386     }
96387   }
96388
96389   jresult = (unsigned long)result;
96390   return jresult;
96391 }
96392
96393
96394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
96395   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96396   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96397
96398   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96399   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96400   {
96401     try {
96402       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96403     } catch (std::out_of_range& e) {
96404       {
96405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96406       };
96407     } catch (std::exception& e) {
96408       {
96409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96410       };
96411     } catch (Dali::DaliException e) {
96412       {
96413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96414       };
96415     } catch (...) {
96416       {
96417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96418       };
96419     }
96420   }
96421
96422 }
96423
96424
96425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
96426   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96427   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
96428
96429   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96430   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
96431   {
96432     try {
96433       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96434     } catch (std::out_of_range& e) {
96435       {
96436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96437       };
96438     } catch (std::exception& e) {
96439       {
96440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96441       };
96442     } catch (Dali::DaliException e) {
96443       {
96444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96445       };
96446     } catch (...) {
96447       {
96448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96449       };
96450     }
96451   }
96452
96453 }
96454
96455
96456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
96457   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96458   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
96459
96460   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96461   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
96462   if (!arg2) {
96463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
96464     return ;
96465   }
96466   {
96467     try {
96468       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
96469     } catch (std::out_of_range& e) {
96470       {
96471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96472       };
96473     } catch (std::exception& e) {
96474       {
96475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96476       };
96477     } catch (Dali::DaliException e) {
96478       {
96479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96480       };
96481     } catch (...) {
96482       {
96483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96484       };
96485     }
96486   }
96487
96488 }
96489
96490
96491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
96492   void * jresult ;
96493   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
96494
96495   {
96496     try {
96497       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
96498     } catch (std::out_of_range& e) {
96499       {
96500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96501       };
96502     } catch (std::exception& e) {
96503       {
96504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96505       };
96506     } catch (Dali::DaliException e) {
96507       {
96508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96509       };
96510     } catch (...) {
96511       {
96512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96513       };
96514     }
96515   }
96516
96517   jresult = (void *)result;
96518   return jresult;
96519 }
96520
96521
96522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
96523   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
96524
96525   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
96526   {
96527     try {
96528       delete arg1;
96529     } catch (std::out_of_range& e) {
96530       {
96531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96532       };
96533     } catch (std::exception& e) {
96534       {
96535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96536       };
96537     } catch (Dali::DaliException e) {
96538       {
96539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96540       };
96541     } catch (...) {
96542       {
96543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96544       };
96545     }
96546   }
96547
96548 }
96549
96550
96551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
96552   unsigned int jresult ;
96553   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96554   bool result;
96555
96556   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96557   {
96558     try {
96559       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96560     } catch (std::out_of_range& e) {
96561       {
96562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96563       };
96564     } catch (std::exception& e) {
96565       {
96566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96567       };
96568     } catch (Dali::DaliException e) {
96569       {
96570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96571       };
96572     } catch (...) {
96573       {
96574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96575       };
96576     }
96577   }
96578
96579   jresult = result;
96580   return jresult;
96581 }
96582
96583
96584 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
96585   unsigned long jresult ;
96586   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96587   std::size_t result;
96588
96589   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96590   {
96591     try {
96592       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
96593     } catch (std::out_of_range& e) {
96594       {
96595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96596       };
96597     } catch (std::exception& e) {
96598       {
96599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96600       };
96601     } catch (Dali::DaliException e) {
96602       {
96603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96604       };
96605     } catch (...) {
96606       {
96607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96608       };
96609     }
96610   }
96611
96612   jresult = (unsigned long)result;
96613   return jresult;
96614 }
96615
96616
96617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
96618   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96619   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96620
96621   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96622   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96623   {
96624     try {
96625       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96626     } catch (std::out_of_range& e) {
96627       {
96628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96629       };
96630     } catch (std::exception& e) {
96631       {
96632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96633       };
96634     } catch (Dali::DaliException e) {
96635       {
96636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96637       };
96638     } catch (...) {
96639       {
96640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96641       };
96642     }
96643   }
96644
96645 }
96646
96647
96648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
96649   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96650   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
96651
96652   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96653   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
96654   {
96655     try {
96656       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96657     } catch (std::out_of_range& e) {
96658       {
96659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96660       };
96661     } catch (std::exception& e) {
96662       {
96663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96664       };
96665     } catch (Dali::DaliException e) {
96666       {
96667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96668       };
96669     } catch (...) {
96670       {
96671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96672       };
96673     }
96674   }
96675
96676 }
96677
96678
96679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
96680   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96681   Dali::Vector2 *arg2 = 0 ;
96682
96683   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96684   arg2 = (Dali::Vector2 *)jarg2;
96685   if (!arg2) {
96686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
96687     return ;
96688   }
96689   {
96690     try {
96691       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
96692     } catch (std::out_of_range& e) {
96693       {
96694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96695       };
96696     } catch (std::exception& e) {
96697       {
96698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96699       };
96700     } catch (Dali::DaliException e) {
96701       {
96702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96703       };
96704     } catch (...) {
96705       {
96706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96707       };
96708     }
96709   }
96710
96711 }
96712
96713
96714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
96715   void * jresult ;
96716   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
96717
96718   {
96719     try {
96720       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
96721     } catch (std::out_of_range& e) {
96722       {
96723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96724       };
96725     } catch (std::exception& e) {
96726       {
96727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96728       };
96729     } catch (Dali::DaliException e) {
96730       {
96731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96732       };
96733     } catch (...) {
96734       {
96735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96736       };
96737     }
96738   }
96739
96740   jresult = (void *)result;
96741   return jresult;
96742 }
96743
96744
96745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
96746   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
96747
96748   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
96749   {
96750     try {
96751       delete arg1;
96752     } catch (std::out_of_range& e) {
96753       {
96754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96755       };
96756     } catch (std::exception& e) {
96757       {
96758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96759       };
96760     } catch (Dali::DaliException e) {
96761       {
96762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96763       };
96764     } catch (...) {
96765       {
96766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96767       };
96768     }
96769   }
96770
96771 }
96772
96773
96774
96775 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
96776   unsigned int jresult ;
96777   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96778   bool result;
96779
96780   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96781   {
96782     try {
96783       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);
96784     } catch (std::out_of_range& e) {
96785       {
96786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96787       };
96788     } catch (std::exception& e) {
96789       {
96790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96791       };
96792     } catch (Dali::DaliException e) {
96793       {
96794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96795       };
96796     } catch (...) {
96797       {
96798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96799       };
96800     }
96801   }
96802
96803   jresult = result;
96804   return jresult;
96805 }
96806
96807
96808 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
96809   unsigned long jresult ;
96810   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96811   std::size_t result;
96812
96813   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96814   {
96815     try {
96816       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);
96817     } catch (std::out_of_range& e) {
96818       {
96819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96820       };
96821     } catch (std::exception& e) {
96822       {
96823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96824       };
96825     } catch (Dali::DaliException e) {
96826       {
96827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96828       };
96829     } catch (...) {
96830       {
96831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96832       };
96833     }
96834   }
96835
96836   jresult = (unsigned long)result;
96837   return jresult;
96838 }
96839
96840
96841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
96842   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96843   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
96844
96845   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96846   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
96847   {
96848     try {
96849       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
96850     } catch (std::out_of_range& e) {
96851       {
96852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96853       };
96854     } catch (std::exception& e) {
96855       {
96856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96857       };
96858     } catch (Dali::DaliException e) {
96859       {
96860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96861       };
96862     } catch (...) {
96863       {
96864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96865       };
96866     }
96867   }
96868
96869 }
96870
96871
96872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
96873   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96874   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
96875
96876   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96877   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
96878   {
96879     try {
96880       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
96881     } catch (std::out_of_range& e) {
96882       {
96883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96884       };
96885     } catch (std::exception& e) {
96886       {
96887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96888       };
96889     } catch (Dali::DaliException e) {
96890       {
96891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96892       };
96893     } catch (...) {
96894       {
96895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96896       };
96897     }
96898   }
96899
96900 }
96901
96902
96903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96904   unsigned int jresult ;
96905   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96906   Dali::Toolkit::Control arg2 ;
96907   Dali::KeyEvent *arg3 = 0 ;
96908   Dali::Toolkit::Control *argp2 ;
96909   bool result;
96910
96911   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96912   argp2 = (Dali::Toolkit::Control *)jarg2;
96913   if (!argp2) {
96914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
96915     return 0;
96916   }
96917   arg2 = *argp2;
96918   arg3 = (Dali::KeyEvent *)jarg3;
96919   if (!arg3) {
96920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
96921     return 0;
96922   }
96923   {
96924     try {
96925       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);
96926     } catch (std::out_of_range& e) {
96927       {
96928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96929       };
96930     } catch (std::exception& e) {
96931       {
96932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96933       };
96934     } catch (Dali::DaliException e) {
96935       {
96936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96937       };
96938     } catch (...) {
96939       {
96940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96941       };
96942     }
96943   }
96944
96945   jresult = result;
96946   return jresult;
96947 }
96948
96949
96950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
96951   void * jresult ;
96952   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
96953
96954   {
96955     try {
96956       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
96957     } catch (std::out_of_range& e) {
96958       {
96959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96960       };
96961     } catch (std::exception& e) {
96962       {
96963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96964       };
96965     } catch (Dali::DaliException e) {
96966       {
96967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96968       };
96969     } catch (...) {
96970       {
96971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96972       };
96973     }
96974   }
96975
96976   jresult = (void *)result;
96977   return jresult;
96978 }
96979
96980
96981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
96982   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
96983
96984   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
96985   {
96986     try {
96987       delete arg1;
96988     } catch (std::out_of_range& e) {
96989       {
96990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96991       };
96992     } catch (std::exception& e) {
96993       {
96994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96995       };
96996     } catch (Dali::DaliException e) {
96997       {
96998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96999       };
97000     } catch (...) {
97001       {
97002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97003       };
97004     }
97005   }
97006
97007 }
97008
97009
97010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97011   unsigned int jresult ;
97012   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97013   bool result;
97014
97015   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97016   {
97017     try {
97018       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97019     } catch (std::out_of_range& e) {
97020       {
97021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97022       };
97023     } catch (std::exception& e) {
97024       {
97025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97026       };
97027     } catch (Dali::DaliException e) {
97028       {
97029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97030       };
97031     } catch (...) {
97032       {
97033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97034       };
97035     }
97036   }
97037
97038   jresult = result;
97039   return jresult;
97040 }
97041
97042
97043 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97044   unsigned long jresult ;
97045   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97046   std::size_t result;
97047
97048   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97049   {
97050     try {
97051       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97052     } catch (std::out_of_range& e) {
97053       {
97054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97055       };
97056     } catch (std::exception& e) {
97057       {
97058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97059       };
97060     } catch (Dali::DaliException e) {
97061       {
97062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97063       };
97064     } catch (...) {
97065       {
97066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97067       };
97068     }
97069   }
97070
97071   jresult = (unsigned long)result;
97072   return jresult;
97073 }
97074
97075
97076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
97077   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97078   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97079
97080   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97081   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97082   {
97083     try {
97084       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97085     } catch (std::out_of_range& e) {
97086       {
97087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97088       };
97089     } catch (std::exception& e) {
97090       {
97091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97092       };
97093     } catch (Dali::DaliException e) {
97094       {
97095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97096       };
97097     } catch (...) {
97098       {
97099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97100       };
97101     }
97102   }
97103
97104 }
97105
97106
97107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
97108   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97109   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97110
97111   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97112   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97113   {
97114     try {
97115       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
97116     } catch (std::out_of_range& e) {
97117       {
97118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97119       };
97120     } catch (std::exception& e) {
97121       {
97122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97123       };
97124     } catch (Dali::DaliException e) {
97125       {
97126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97127       };
97128     } catch (...) {
97129       {
97130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97131       };
97132     }
97133   }
97134
97135 }
97136
97137
97138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
97139   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97140   Dali::Toolkit::Control arg2 ;
97141   Dali::Toolkit::Control *argp2 ;
97142
97143   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97144   argp2 = (Dali::Toolkit::Control *)jarg2;
97145   if (!argp2) {
97146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97147     return ;
97148   }
97149   arg2 = *argp2;
97150   {
97151     try {
97152       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
97153     } catch (std::out_of_range& e) {
97154       {
97155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97156       };
97157     } catch (std::exception& e) {
97158       {
97159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97160       };
97161     } catch (Dali::DaliException e) {
97162       {
97163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97164       };
97165     } catch (...) {
97166       {
97167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97168       };
97169     }
97170   }
97171
97172 }
97173
97174
97175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
97176   void * jresult ;
97177   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
97178
97179   {
97180     try {
97181       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
97182     } catch (std::out_of_range& e) {
97183       {
97184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97185       };
97186     } catch (std::exception& e) {
97187       {
97188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97189       };
97190     } catch (Dali::DaliException e) {
97191       {
97192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97193       };
97194     } catch (...) {
97195       {
97196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97197       };
97198     }
97199   }
97200
97201   jresult = (void *)result;
97202   return jresult;
97203 }
97204
97205
97206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
97207   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97208
97209   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97210   {
97211     try {
97212       delete arg1;
97213     } catch (std::out_of_range& e) {
97214       {
97215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97216       };
97217     } catch (std::exception& e) {
97218       {
97219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97220       };
97221     } catch (Dali::DaliException e) {
97222       {
97223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97224       };
97225     } catch (...) {
97226       {
97227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97228       };
97229     }
97230   }
97231
97232 }
97233
97234
97235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
97236   unsigned int jresult ;
97237   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97238   bool result;
97239
97240   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97241   {
97242     try {
97243       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97244     } catch (std::out_of_range& e) {
97245       {
97246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97247       };
97248     } catch (std::exception& e) {
97249       {
97250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97251       };
97252     } catch (Dali::DaliException e) {
97253       {
97254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97255       };
97256     } catch (...) {
97257       {
97258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97259       };
97260     }
97261   }
97262
97263   jresult = result;
97264   return jresult;
97265 }
97266
97267
97268 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
97269   unsigned long jresult ;
97270   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97271   std::size_t result;
97272
97273   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97274   {
97275     try {
97276       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
97277     } catch (std::out_of_range& e) {
97278       {
97279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97280       };
97281     } catch (std::exception& e) {
97282       {
97283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97284       };
97285     } catch (Dali::DaliException e) {
97286       {
97287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97288       };
97289     } catch (...) {
97290       {
97291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97292       };
97293     }
97294   }
97295
97296   jresult = (unsigned long)result;
97297   return jresult;
97298 }
97299
97300
97301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
97302   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97303   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97304
97305   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97306   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97307   {
97308     try {
97309       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
97310     } catch (std::out_of_range& e) {
97311       {
97312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97313       };
97314     } catch (std::exception& e) {
97315       {
97316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97317       };
97318     } catch (Dali::DaliException e) {
97319       {
97320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97321       };
97322     } catch (...) {
97323       {
97324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97325       };
97326     }
97327   }
97328
97329 }
97330
97331
97332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
97333   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97334   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
97335
97336   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97337   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
97338   {
97339     try {
97340       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
97341     } catch (std::out_of_range& e) {
97342       {
97343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97344       };
97345     } catch (std::exception& e) {
97346       {
97347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97348       };
97349     } catch (Dali::DaliException e) {
97350       {
97351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97352       };
97353     } catch (...) {
97354       {
97355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97356       };
97357     }
97358   }
97359
97360 }
97361
97362
97363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
97364   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97365   Dali::Toolkit::VideoView *arg2 = 0 ;
97366
97367   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97368   arg2 = (Dali::Toolkit::VideoView *)jarg2;
97369   if (!arg2) {
97370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
97371     return ;
97372   }
97373   {
97374     try {
97375       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
97376     } catch (std::out_of_range& e) {
97377       {
97378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97379       };
97380     } catch (std::exception& e) {
97381       {
97382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97383       };
97384     } catch (Dali::DaliException e) {
97385       {
97386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97387       };
97388     } catch (...) {
97389       {
97390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97391       };
97392     }
97393   }
97394
97395 }
97396
97397
97398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
97399   void * jresult ;
97400   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
97401
97402   {
97403     try {
97404       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
97405     } catch (std::out_of_range& e) {
97406       {
97407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97408       };
97409     } catch (std::exception& e) {
97410       {
97411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97412       };
97413     } catch (Dali::DaliException e) {
97414       {
97415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97416       };
97417     } catch (...) {
97418       {
97419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97420       };
97421     }
97422   }
97423
97424   jresult = (void *)result;
97425   return jresult;
97426 }
97427
97428
97429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
97430   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
97431
97432   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
97433   {
97434     try {
97435       delete arg1;
97436     } catch (std::out_of_range& e) {
97437       {
97438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97439       };
97440     } catch (std::exception& e) {
97441       {
97442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97443       };
97444     } catch (Dali::DaliException e) {
97445       {
97446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97447       };
97448     } catch (...) {
97449       {
97450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97451       };
97452     }
97453   }
97454
97455 }
97456
97457
97458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
97459   unsigned int jresult ;
97460   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97461   bool result;
97462
97463   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97464   {
97465     try {
97466       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97467     } catch (std::out_of_range& e) {
97468       {
97469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97470       };
97471     } catch (std::exception& e) {
97472       {
97473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97474       };
97475     } catch (Dali::DaliException e) {
97476       {
97477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97478       };
97479     } catch (...) {
97480       {
97481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97482       };
97483     }
97484   }
97485
97486   jresult = result;
97487   return jresult;
97488 }
97489
97490
97491 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
97492   unsigned long jresult ;
97493   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97494   std::size_t result;
97495
97496   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97497   {
97498     try {
97499       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
97500     } catch (std::out_of_range& e) {
97501       {
97502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97503       };
97504     } catch (std::exception& e) {
97505       {
97506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97507       };
97508     } catch (Dali::DaliException e) {
97509       {
97510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97511       };
97512     } catch (...) {
97513       {
97514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97515       };
97516     }
97517   }
97518
97519   jresult = (unsigned long)result;
97520   return jresult;
97521 }
97522
97523
97524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97525   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97526   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97527
97528   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97529   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97530   {
97531     try {
97532       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
97533     } catch (std::out_of_range& e) {
97534       {
97535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97536       };
97537     } catch (std::exception& e) {
97538       {
97539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97540       };
97541     } catch (Dali::DaliException e) {
97542       {
97543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97544       };
97545     } catch (...) {
97546       {
97547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97548       };
97549     }
97550   }
97551
97552 }
97553
97554
97555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97556   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97557   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
97558
97559   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97560   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
97561   {
97562     try {
97563       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97564     } catch (std::out_of_range& e) {
97565       {
97566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97567       };
97568     } catch (std::exception& e) {
97569       {
97570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97571       };
97572     } catch (Dali::DaliException e) {
97573       {
97574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97575       };
97576     } catch (...) {
97577       {
97578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97579       };
97580     }
97581   }
97582
97583 }
97584
97585
97586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
97587   unsigned int jresult ;
97588   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97589   Dali::Toolkit::Slider arg2 ;
97590   float arg3 ;
97591   Dali::Toolkit::Slider *argp2 ;
97592   bool result;
97593
97594   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97595   argp2 = (Dali::Toolkit::Slider *)jarg2;
97596   if (!argp2) {
97597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97598     return 0;
97599   }
97600   arg2 = *argp2;
97601   arg3 = (float)jarg3;
97602   {
97603     try {
97604       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
97605     } catch (std::out_of_range& e) {
97606       {
97607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97608       };
97609     } catch (std::exception& e) {
97610       {
97611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97612       };
97613     } catch (Dali::DaliException e) {
97614       {
97615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97616       };
97617     } catch (...) {
97618       {
97619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97620       };
97621     }
97622   }
97623
97624   jresult = result;
97625   return jresult;
97626 }
97627
97628
97629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
97630   void * jresult ;
97631   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
97632
97633   {
97634     try {
97635       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
97636     } catch (std::out_of_range& e) {
97637       {
97638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97639       };
97640     } catch (std::exception& e) {
97641       {
97642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97643       };
97644     } catch (Dali::DaliException e) {
97645       {
97646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97647       };
97648     } catch (...) {
97649       {
97650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97651       };
97652     }
97653   }
97654
97655   jresult = (void *)result;
97656   return jresult;
97657 }
97658
97659
97660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
97661   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
97662
97663   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
97664   {
97665     try {
97666       delete arg1;
97667     } catch (std::out_of_range& e) {
97668       {
97669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97670       };
97671     } catch (std::exception& e) {
97672       {
97673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97674       };
97675     } catch (Dali::DaliException e) {
97676       {
97677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97678       };
97679     } catch (...) {
97680       {
97681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97682       };
97683     }
97684   }
97685
97686 }
97687
97688
97689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
97690   unsigned int jresult ;
97691   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97692   bool result;
97693
97694   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97695   {
97696     try {
97697       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97698     } catch (std::out_of_range& e) {
97699       {
97700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97701       };
97702     } catch (std::exception& e) {
97703       {
97704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97705       };
97706     } catch (Dali::DaliException e) {
97707       {
97708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97709       };
97710     } catch (...) {
97711       {
97712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97713       };
97714     }
97715   }
97716
97717   jresult = result;
97718   return jresult;
97719 }
97720
97721
97722 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
97723   unsigned long jresult ;
97724   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97725   std::size_t result;
97726
97727   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97728   {
97729     try {
97730       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
97731     } catch (std::out_of_range& e) {
97732       {
97733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97734       };
97735     } catch (std::exception& e) {
97736       {
97737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97738       };
97739     } catch (Dali::DaliException e) {
97740       {
97741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97742       };
97743     } catch (...) {
97744       {
97745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97746       };
97747     }
97748   }
97749
97750   jresult = (unsigned long)result;
97751   return jresult;
97752 }
97753
97754
97755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
97756   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97757   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97758
97759   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97760   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97761   {
97762     try {
97763       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
97764     } catch (std::out_of_range& e) {
97765       {
97766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97767       };
97768     } catch (std::exception& e) {
97769       {
97770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97771       };
97772     } catch (Dali::DaliException e) {
97773       {
97774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97775       };
97776     } catch (...) {
97777       {
97778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97779       };
97780     }
97781   }
97782
97783 }
97784
97785
97786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
97787   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97788   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
97789
97790   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97791   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
97792   {
97793     try {
97794       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
97795     } catch (std::out_of_range& e) {
97796       {
97797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97798       };
97799     } catch (std::exception& e) {
97800       {
97801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97802       };
97803     } catch (Dali::DaliException e) {
97804       {
97805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97806       };
97807     } catch (...) {
97808       {
97809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97810       };
97811     }
97812   }
97813
97814 }
97815
97816
97817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
97818   unsigned int jresult ;
97819   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97820   Dali::Toolkit::Slider arg2 ;
97821   int arg3 ;
97822   Dali::Toolkit::Slider *argp2 ;
97823   bool result;
97824
97825   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97826   argp2 = (Dali::Toolkit::Slider *)jarg2;
97827   if (!argp2) {
97828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
97829     return 0;
97830   }
97831   arg2 = *argp2;
97832   arg3 = (int)jarg3;
97833   {
97834     try {
97835       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
97836     } catch (std::out_of_range& e) {
97837       {
97838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97839       };
97840     } catch (std::exception& e) {
97841       {
97842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97843       };
97844     } catch (Dali::DaliException e) {
97845       {
97846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97847       };
97848     } catch (...) {
97849       {
97850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97851       };
97852     }
97853   }
97854
97855   jresult = result;
97856   return jresult;
97857 }
97858
97859
97860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
97861   void * jresult ;
97862   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
97863
97864   {
97865     try {
97866       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
97867     } catch (std::out_of_range& e) {
97868       {
97869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97870       };
97871     } catch (std::exception& e) {
97872       {
97873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97874       };
97875     } catch (Dali::DaliException e) {
97876       {
97877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97878       };
97879     } catch (...) {
97880       {
97881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97882       };
97883     }
97884   }
97885
97886   jresult = (void *)result;
97887   return jresult;
97888 }
97889
97890
97891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
97892   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
97893
97894   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
97895   {
97896     try {
97897       delete arg1;
97898     } catch (std::out_of_range& e) {
97899       {
97900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97901       };
97902     } catch (std::exception& e) {
97903       {
97904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97905       };
97906     } catch (Dali::DaliException e) {
97907       {
97908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97909       };
97910     } catch (...) {
97911       {
97912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97913       };
97914     }
97915   }
97916
97917 }
97918
97919
97920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
97921   void * jresult ;
97922   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97923
97924   {
97925     try {
97926       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
97927     } catch (std::out_of_range& e) {
97928       {
97929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97930       };
97931     } catch (std::exception& e) {
97932       {
97933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97934       };
97935     } catch (Dali::DaliException e) {
97936       {
97937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97938       };
97939     } catch (...) {
97940       {
97941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97942       };
97943     }
97944   }
97945
97946   jresult = (void *)result;
97947   return jresult;
97948 }
97949
97950
97951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
97952   void * jresult ;
97953   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
97954   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97955
97956   arg1 = (Dali::Toolkit::Ruler *)jarg1;
97957   {
97958     try {
97959       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
97960     } catch (std::out_of_range& e) {
97961       {
97962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97963       };
97964     } catch (std::exception& e) {
97965       {
97966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97967       };
97968     } catch (Dali::DaliException e) {
97969       {
97970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97971       };
97972     } catch (...) {
97973       {
97974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97975       };
97976     }
97977   }
97978
97979   jresult = (void *)result;
97980   return jresult;
97981 }
97982
97983
97984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
97985   void * jresult ;
97986   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
97987   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97988
97989   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97990   if (!arg1) {
97991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
97992     return 0;
97993   }
97994   {
97995     try {
97996       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
97997     } catch (std::out_of_range& e) {
97998       {
97999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98000       };
98001     } catch (std::exception& e) {
98002       {
98003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98004       };
98005     } catch (Dali::DaliException e) {
98006       {
98007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98008       };
98009     } catch (...) {
98010       {
98011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98012       };
98013     }
98014   }
98015
98016   jresult = (void *)result;
98017   return jresult;
98018 }
98019
98020
98021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98022   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98023
98024   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98025   {
98026     try {
98027       delete arg1;
98028     } catch (std::out_of_range& e) {
98029       {
98030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98031       };
98032     } catch (std::exception& e) {
98033       {
98034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98035       };
98036     } catch (Dali::DaliException e) {
98037       {
98038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98039       };
98040     } catch (...) {
98041       {
98042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98043       };
98044     }
98045   }
98046
98047 }
98048
98049
98050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98051   void * jresult ;
98052   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98053   Dali::Toolkit::Ruler *result = 0 ;
98054
98055   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98056   {
98057     try {
98058       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98059     } catch (std::out_of_range& e) {
98060       {
98061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98062       };
98063     } catch (std::exception& e) {
98064       {
98065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98066       };
98067     } catch (Dali::DaliException e) {
98068       {
98069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98070       };
98071     } catch (...) {
98072       {
98073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98074       };
98075     }
98076   }
98077
98078   jresult = (void *)result;
98079   return jresult;
98080 }
98081
98082
98083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
98084   void * jresult ;
98085   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98086   Dali::Toolkit::Ruler *result = 0 ;
98087
98088   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98089   {
98090     try {
98091       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
98092     } catch (std::out_of_range& e) {
98093       {
98094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98095       };
98096     } catch (std::exception& e) {
98097       {
98098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98099       };
98100     } catch (Dali::DaliException e) {
98101       {
98102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98103       };
98104     } catch (...) {
98105       {
98106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98107       };
98108     }
98109   }
98110
98111   jresult = (void *)result;
98112   return jresult;
98113 }
98114
98115
98116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
98117   void * jresult ;
98118   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98119   Dali::Toolkit::Ruler *result = 0 ;
98120
98121   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98122   {
98123     try {
98124       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
98125     } catch (std::out_of_range& e) {
98126       {
98127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98128       };
98129     } catch (std::exception& e) {
98130       {
98131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98132       };
98133     } catch (Dali::DaliException e) {
98134       {
98135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98136       };
98137     } catch (...) {
98138       {
98139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98140       };
98141     }
98142   }
98143
98144   jresult = (void *)result;
98145   return jresult;
98146 }
98147
98148
98149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
98150   void * jresult ;
98151   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98152   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
98153   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98154
98155   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98156   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
98157   if (!arg2) {
98158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98159     return 0;
98160   }
98161   {
98162     try {
98163       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
98164     } catch (std::out_of_range& e) {
98165       {
98166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98167       };
98168     } catch (std::exception& e) {
98169       {
98170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98171       };
98172     } catch (Dali::DaliException e) {
98173       {
98174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98175       };
98176     } catch (...) {
98177       {
98178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98179       };
98180     }
98181   }
98182
98183   jresult = (void *)result;
98184   return jresult;
98185 }
98186
98187
98188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
98189   void * jresult ;
98190   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98191   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98192   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98193
98194   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98195   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98196   {
98197     try {
98198       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
98199     } catch (std::out_of_range& e) {
98200       {
98201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98202       };
98203     } catch (std::exception& e) {
98204       {
98205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98206       };
98207     } catch (Dali::DaliException e) {
98208       {
98209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98210       };
98211     } catch (...) {
98212       {
98213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98214       };
98215     }
98216   }
98217
98218   jresult = (void *)result;
98219   return jresult;
98220 }
98221
98222
98223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
98224   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98225
98226   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98227   {
98228     try {
98229       (arg1)->Reset();
98230     } catch (std::out_of_range& e) {
98231       {
98232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98233       };
98234     } catch (std::exception& e) {
98235       {
98236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98237       };
98238     } catch (Dali::DaliException e) {
98239       {
98240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98241       };
98242     } catch (...) {
98243       {
98244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98245       };
98246     }
98247   }
98248
98249 }
98250
98251
98252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
98253   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98254   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
98255
98256   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98257   arg2 = (Dali::Toolkit::Ruler *)jarg2;
98258   {
98259     try {
98260       (arg1)->Reset(arg2);
98261     } catch (std::out_of_range& e) {
98262       {
98263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98264       };
98265     } catch (std::exception& e) {
98266       {
98267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98268       };
98269     } catch (Dali::DaliException e) {
98270       {
98271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98272       };
98273     } catch (...) {
98274       {
98275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98276       };
98277     }
98278   }
98279
98280 }
98281
98282
98283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
98284   void * jresult ;
98285   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98286   Dali::Toolkit::Ruler *result = 0 ;
98287
98288   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98289   {
98290     try {
98291       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
98292     } catch (std::out_of_range& e) {
98293       {
98294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98295       };
98296     } catch (std::exception& e) {
98297       {
98298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98299       };
98300     } catch (Dali::DaliException e) {
98301       {
98302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98303       };
98304     } catch (...) {
98305       {
98306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98307       };
98308     }
98309   }
98310
98311   jresult = (void *)result;
98312   return jresult;
98313 }
98314
98315
98316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
98317   float jresult ;
98318   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98319   float arg2 ;
98320   float arg3 ;
98321   float result;
98322
98323   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98324   arg2 = (float)jarg2;
98325   arg3 = (float)jarg3;
98326   {
98327     try {
98328       result = (float)(*arg1)->Snap(arg2,arg3);
98329     } catch (std::out_of_range& e) {
98330       {
98331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98332       };
98333     } catch (std::exception& e) {
98334       {
98335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98336       };
98337     } catch (Dali::DaliException e) {
98338       {
98339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98340       };
98341     } catch (...) {
98342       {
98343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98344       };
98345     }
98346   }
98347
98348   jresult = result;
98349   return jresult;
98350 }
98351
98352
98353 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
98354   float jresult ;
98355   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98356   float arg2 ;
98357   float result;
98358
98359   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98360   arg2 = (float)jarg2;
98361   {
98362     try {
98363       result = (float)(*arg1)->Snap(arg2);
98364     } catch (std::out_of_range& e) {
98365       {
98366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98367       };
98368     } catch (std::exception& e) {
98369       {
98370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98371       };
98372     } catch (Dali::DaliException e) {
98373       {
98374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98375       };
98376     } catch (...) {
98377       {
98378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98379       };
98380     }
98381   }
98382
98383   jresult = result;
98384   return jresult;
98385 }
98386
98387
98388 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
98389   float jresult ;
98390   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98391   unsigned int arg2 ;
98392   unsigned int *arg3 = 0 ;
98393   bool arg4 ;
98394   float result;
98395
98396   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98397   arg2 = (unsigned int)jarg2;
98398   arg3 = (unsigned int *)jarg3;
98399   arg4 = jarg4 ? true : false;
98400   {
98401     try {
98402       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
98403     } catch (std::out_of_range& e) {
98404       {
98405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98406       };
98407     } catch (std::exception& e) {
98408       {
98409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98410       };
98411     } catch (Dali::DaliException e) {
98412       {
98413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98414       };
98415     } catch (...) {
98416       {
98417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98418       };
98419     }
98420   }
98421
98422   jresult = result;
98423   return jresult;
98424 }
98425
98426
98427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
98428   unsigned int jresult ;
98429   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98430   float arg2 ;
98431   bool arg3 ;
98432   unsigned int result;
98433
98434   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98435   arg2 = (float)jarg2;
98436   arg3 = jarg3 ? true : false;
98437   {
98438     try {
98439       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
98440     } catch (std::out_of_range& e) {
98441       {
98442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98443       };
98444     } catch (std::exception& e) {
98445       {
98446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98447       };
98448     } catch (Dali::DaliException e) {
98449       {
98450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98451       };
98452     } catch (...) {
98453       {
98454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98455       };
98456     }
98457   }
98458
98459   jresult = result;
98460   return jresult;
98461 }
98462
98463
98464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
98465   unsigned int jresult ;
98466   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98467   unsigned int result;
98468
98469   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98470   {
98471     try {
98472       result = (unsigned int)(*arg1)->GetTotalPages();
98473     } catch (std::out_of_range& e) {
98474       {
98475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98476       };
98477     } catch (std::exception& e) {
98478       {
98479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98480       };
98481     } catch (Dali::DaliException e) {
98482       {
98483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98484       };
98485     } catch (...) {
98486       {
98487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98488       };
98489     }
98490   }
98491
98492   jresult = result;
98493   return jresult;
98494 }
98495
98496
98497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
98498   int jresult ;
98499   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98500   Dali::Toolkit::Ruler::RulerType result;
98501
98502   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98503   {
98504     try {
98505       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
98506     } catch (std::out_of_range& e) {
98507       {
98508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98509       };
98510     } catch (std::exception& e) {
98511       {
98512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98513       };
98514     } catch (Dali::DaliException e) {
98515       {
98516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98517       };
98518     } catch (...) {
98519       {
98520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98521       };
98522     }
98523   }
98524
98525   jresult = (int)result;
98526   return jresult;
98527 }
98528
98529
98530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
98531   unsigned int jresult ;
98532   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98533   bool result;
98534
98535   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98536   {
98537     try {
98538       result = (bool)(*arg1)->IsEnabled();
98539     } catch (std::out_of_range& e) {
98540       {
98541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98542       };
98543     } catch (std::exception& e) {
98544       {
98545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98546       };
98547     } catch (Dali::DaliException e) {
98548       {
98549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98550       };
98551     } catch (...) {
98552       {
98553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98554       };
98555     }
98556   }
98557
98558   jresult = result;
98559   return jresult;
98560 }
98561
98562
98563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
98564   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98565
98566   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98567   {
98568     try {
98569       (*arg1)->Enable();
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 (Dali::DaliException e) {
98579       {
98580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98581       };
98582     } catch (...) {
98583       {
98584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98585       };
98586     }
98587   }
98588
98589 }
98590
98591
98592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
98593   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98594
98595   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98596   {
98597     try {
98598       (*arg1)->Disable();
98599     } catch (std::out_of_range& e) {
98600       {
98601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98602       };
98603     } catch (std::exception& e) {
98604       {
98605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98606       };
98607     } catch (Dali::DaliException e) {
98608       {
98609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98610       };
98611     } catch (...) {
98612       {
98613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98614       };
98615     }
98616   }
98617
98618 }
98619
98620
98621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
98622   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98623   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
98624   Dali::Toolkit::RulerDomain *argp2 ;
98625
98626   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98627   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
98628   if (!argp2) {
98629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
98630     return ;
98631   }
98632   arg2 = *argp2;
98633   {
98634     try {
98635       (*arg1)->SetDomain(arg2);
98636     } catch (std::out_of_range& e) {
98637       {
98638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98639       };
98640     } catch (std::exception& e) {
98641       {
98642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98643       };
98644     } catch (Dali::DaliException e) {
98645       {
98646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98647       };
98648     } catch (...) {
98649       {
98650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98651       };
98652     }
98653   }
98654
98655 }
98656
98657
98658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
98659   void * jresult ;
98660   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98661   Dali::Toolkit::RulerDomain *result = 0 ;
98662
98663   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98664   {
98665     try {
98666       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
98667     } catch (std::out_of_range& e) {
98668       {
98669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98670       };
98671     } catch (std::exception& e) {
98672       {
98673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98674       };
98675     } catch (Dali::DaliException e) {
98676       {
98677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98678       };
98679     } catch (...) {
98680       {
98681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98682       };
98683     }
98684   }
98685
98686   jresult = (void *)result;
98687   return jresult;
98688 }
98689
98690
98691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
98692   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98693
98694   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98695   {
98696     try {
98697       (*arg1)->DisableDomain();
98698     } catch (std::out_of_range& e) {
98699       {
98700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98701       };
98702     } catch (std::exception& e) {
98703       {
98704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98705       };
98706     } catch (Dali::DaliException e) {
98707       {
98708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98709       };
98710     } catch (...) {
98711       {
98712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98713       };
98714     }
98715   }
98716
98717 }
98718
98719
98720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
98721   float jresult ;
98722   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98723   float arg2 ;
98724   float arg3 ;
98725   float arg4 ;
98726   float result;
98727
98728   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98729   arg2 = (float)jarg2;
98730   arg3 = (float)jarg3;
98731   arg4 = (float)jarg4;
98732   {
98733     try {
98734       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
98735     } catch (std::out_of_range& e) {
98736       {
98737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98738       };
98739     } catch (std::exception& e) {
98740       {
98741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98742       };
98743     } catch (Dali::DaliException e) {
98744       {
98745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98746       };
98747     } catch (...) {
98748       {
98749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98750       };
98751     }
98752   }
98753
98754   jresult = result;
98755   return jresult;
98756 }
98757
98758
98759 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
98760   float jresult ;
98761   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98762   float arg2 ;
98763   float arg3 ;
98764   float result;
98765
98766   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98767   arg2 = (float)jarg2;
98768   arg3 = (float)jarg3;
98769   {
98770     try {
98771       result = (float)(*arg1)->Clamp(arg2,arg3);
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 (Dali::DaliException e) {
98781       {
98782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98783       };
98784     } catch (...) {
98785       {
98786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98787       };
98788     }
98789   }
98790
98791   jresult = result;
98792   return jresult;
98793 }
98794
98795
98796 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
98797   float jresult ;
98798   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98799   float arg2 ;
98800   float result;
98801
98802   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98803   arg2 = (float)jarg2;
98804   {
98805     try {
98806       result = (float)(*arg1)->Clamp(arg2);
98807     } catch (std::out_of_range& e) {
98808       {
98809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98810       };
98811     } catch (std::exception& e) {
98812       {
98813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98814       };
98815     } catch (Dali::DaliException e) {
98816       {
98817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98818       };
98819     } catch (...) {
98820       {
98821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98822       };
98823     }
98824   }
98825
98826   jresult = result;
98827   return jresult;
98828 }
98829
98830
98831 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
98832   float jresult ;
98833   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98834   float arg2 ;
98835   float arg3 ;
98836   float arg4 ;
98837   Dali::Toolkit::ClampState *arg5 = 0 ;
98838   float result;
98839
98840   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98841   arg2 = (float)jarg2;
98842   arg3 = (float)jarg3;
98843   arg4 = (float)jarg4;
98844   arg5 = (Dali::Toolkit::ClampState *)jarg5;
98845   if (!arg5) {
98846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
98847     return 0;
98848   }
98849   {
98850     try {
98851       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
98852     } catch (std::out_of_range& e) {
98853       {
98854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98855       };
98856     } catch (std::exception& e) {
98857       {
98858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98859       };
98860     } catch (Dali::DaliException e) {
98861       {
98862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98863       };
98864     } catch (...) {
98865       {
98866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98867       };
98868     }
98869   }
98870
98871   jresult = result;
98872   return jresult;
98873 }
98874
98875
98876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
98877   float jresult ;
98878   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98879   float arg2 ;
98880   float arg3 ;
98881   float arg4 ;
98882   float arg5 ;
98883   float result;
98884
98885   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98886   arg2 = (float)jarg2;
98887   arg3 = (float)jarg3;
98888   arg4 = (float)jarg4;
98889   arg5 = (float)jarg5;
98890   {
98891     try {
98892       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
98893     } catch (std::out_of_range& e) {
98894       {
98895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98896       };
98897     } catch (std::exception& e) {
98898       {
98899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98900       };
98901     } catch (Dali::DaliException e) {
98902       {
98903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98904       };
98905     } catch (...) {
98906       {
98907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98908       };
98909     }
98910   }
98911
98912   jresult = result;
98913   return jresult;
98914 }
98915
98916
98917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
98918   float jresult ;
98919   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98920   float arg2 ;
98921   float arg3 ;
98922   float arg4 ;
98923   float result;
98924
98925   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98926   arg2 = (float)jarg2;
98927   arg3 = (float)jarg3;
98928   arg4 = (float)jarg4;
98929   {
98930     try {
98931       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
98932     } catch (std::out_of_range& e) {
98933       {
98934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98935       };
98936     } catch (std::exception& e) {
98937       {
98938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98939       };
98940     } catch (Dali::DaliException e) {
98941       {
98942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98943       };
98944     } catch (...) {
98945       {
98946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98947       };
98948     }
98949   }
98950
98951   jresult = result;
98952   return jresult;
98953 }
98954
98955
98956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
98957   float jresult ;
98958   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98959   float arg2 ;
98960   float arg3 ;
98961   float result;
98962
98963   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98964   arg2 = (float)jarg2;
98965   arg3 = (float)jarg3;
98966   {
98967     try {
98968       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
98969     } catch (std::out_of_range& e) {
98970       {
98971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98972       };
98973     } catch (std::exception& e) {
98974       {
98975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98976       };
98977     } catch (Dali::DaliException e) {
98978       {
98979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98980       };
98981     } catch (...) {
98982       {
98983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98984       };
98985     }
98986   }
98987
98988   jresult = result;
98989   return jresult;
98990 }
98991
98992
98993 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
98994   float jresult ;
98995   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98996   float arg2 ;
98997   float result;
98998
98999   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99000   arg2 = (float)jarg2;
99001   {
99002     try {
99003       result = (float)(*arg1)->SnapAndClamp(arg2);
99004     } catch (std::out_of_range& e) {
99005       {
99006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99007       };
99008     } catch (std::exception& e) {
99009       {
99010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99011       };
99012     } catch (Dali::DaliException e) {
99013       {
99014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99015       };
99016     } catch (...) {
99017       {
99018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99019       };
99020     }
99021   }
99022
99023   jresult = result;
99024   return jresult;
99025 }
99026
99027
99028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99029   float jresult ;
99030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99031   float arg2 ;
99032   float arg3 ;
99033   float arg4 ;
99034   float arg5 ;
99035   Dali::Toolkit::ClampState *arg6 = 0 ;
99036   float result;
99037
99038   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99039   arg2 = (float)jarg2;
99040   arg3 = (float)jarg3;
99041   arg4 = (float)jarg4;
99042   arg5 = (float)jarg5;
99043   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99044   if (!arg6) {
99045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99046     return 0;
99047   }
99048   {
99049     try {
99050       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99051     } catch (std::out_of_range& e) {
99052       {
99053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99054       };
99055     } catch (std::exception& e) {
99056       {
99057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99058       };
99059     } catch (Dali::DaliException e) {
99060       {
99061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99062       };
99063     } catch (...) {
99064       {
99065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99066       };
99067     }
99068   }
99069
99070   jresult = result;
99071   return jresult;
99072 }
99073
99074
99075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
99076   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99077
99078   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99079   {
99080     try {
99081       (*arg1)->Reference();
99082     } catch (std::out_of_range& e) {
99083       {
99084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99085       };
99086     } catch (std::exception& e) {
99087       {
99088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99089       };
99090     } catch (Dali::DaliException e) {
99091       {
99092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99093       };
99094     } catch (...) {
99095       {
99096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99097       };
99098     }
99099   }
99100
99101 }
99102
99103
99104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
99105   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99106
99107   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99108   {
99109     try {
99110       (*arg1)->Unreference();
99111     } catch (std::out_of_range& e) {
99112       {
99113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99114       };
99115     } catch (std::exception& e) {
99116       {
99117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99118       };
99119     } catch (Dali::DaliException e) {
99120       {
99121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99122       };
99123     } catch (...) {
99124       {
99125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99126       };
99127     }
99128   }
99129
99130 }
99131
99132
99133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
99134   int jresult ;
99135   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99136   int result;
99137
99138   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99139   {
99140     try {
99141       result = (int)(*arg1)->ReferenceCount();
99142     } catch (std::out_of_range& e) {
99143       {
99144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99145       };
99146     } catch (std::exception& e) {
99147       {
99148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99149       };
99150     } catch (Dali::DaliException e) {
99151       {
99152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99153       };
99154     } catch (...) {
99155       {
99156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99157       };
99158     }
99159   }
99160
99161   jresult = result;
99162   return jresult;
99163 }
99164
99165
99166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
99167   unsigned int jresult ;
99168   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99169   bool result;
99170
99171   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99172   {
99173     try {
99174       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99175     } catch (std::out_of_range& e) {
99176       {
99177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99178       };
99179     } catch (std::exception& e) {
99180       {
99181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99182       };
99183     } catch (Dali::DaliException e) {
99184       {
99185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99186       };
99187     } catch (...) {
99188       {
99189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99190       };
99191     }
99192   }
99193
99194   jresult = result;
99195   return jresult;
99196 }
99197
99198
99199 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
99200   unsigned long jresult ;
99201   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99202   std::size_t result;
99203
99204   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99205   {
99206     try {
99207       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
99208     } catch (std::out_of_range& e) {
99209       {
99210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99211       };
99212     } catch (std::exception& e) {
99213       {
99214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99215       };
99216     } catch (Dali::DaliException e) {
99217       {
99218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99219       };
99220     } catch (...) {
99221       {
99222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99223       };
99224     }
99225   }
99226
99227   jresult = (unsigned long)result;
99228   return jresult;
99229 }
99230
99231
99232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
99233   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99234   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99235
99236   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99237   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99238   {
99239     try {
99240       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
99241     } catch (std::out_of_range& e) {
99242       {
99243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99244       };
99245     } catch (std::exception& e) {
99246       {
99247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99248       };
99249     } catch (Dali::DaliException e) {
99250       {
99251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99252       };
99253     } catch (...) {
99254       {
99255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99256       };
99257     }
99258   }
99259
99260 }
99261
99262
99263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
99264   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99265   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
99266
99267   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99268   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
99269   {
99270     try {
99271       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
99272     } catch (std::out_of_range& e) {
99273       {
99274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99275       };
99276     } catch (std::exception& e) {
99277       {
99278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99279       };
99280     } catch (Dali::DaliException e) {
99281       {
99282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99283       };
99284     } catch (...) {
99285       {
99286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99287       };
99288     }
99289   }
99290
99291 }
99292
99293
99294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
99295   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99296   Dali::Toolkit::Control arg2 ;
99297   Dali::Toolkit::Control *argp2 ;
99298
99299   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99300   argp2 = (Dali::Toolkit::Control *)jarg2;
99301   if (!argp2) {
99302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
99303     return ;
99304   }
99305   arg2 = *argp2;
99306   {
99307     try {
99308       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
99309     } catch (std::out_of_range& e) {
99310       {
99311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99312       };
99313     } catch (std::exception& e) {
99314       {
99315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99316       };
99317     } catch (Dali::DaliException e) {
99318       {
99319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99320       };
99321     } catch (...) {
99322       {
99323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99324       };
99325     }
99326   }
99327
99328 }
99329
99330
99331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
99332   void * jresult ;
99333   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
99334
99335   {
99336     try {
99337       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
99338     } catch (std::out_of_range& e) {
99339       {
99340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99341       };
99342     } catch (std::exception& e) {
99343       {
99344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99345       };
99346     } catch (Dali::DaliException e) {
99347       {
99348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99349       };
99350     } catch (...) {
99351       {
99352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99353       };
99354     }
99355   }
99356
99357   jresult = (void *)result;
99358   return jresult;
99359 }
99360
99361
99362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
99363   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99364
99365   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99366   {
99367     try {
99368       delete arg1;
99369     } catch (std::out_of_range& e) {
99370       {
99371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99372       };
99373     } catch (std::exception& e) {
99374       {
99375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99376       };
99377     } catch (Dali::DaliException e) {
99378       {
99379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99380       };
99381     } catch (...) {
99382       {
99383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99384       };
99385     }
99386   }
99387
99388 }
99389
99390 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
99391   Dali::RefObject *result = NULL;
99392
99393   if (arg1)
99394   {
99395     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
99396   }
99397   return result;
99398 }
99399
99400 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
99401     return (Dali::RefObject *)jarg1;
99402 }
99403
99404 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
99405     return (Dali::SignalObserver *)jarg1;
99406 }
99407
99408 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
99409     return (Dali::ConnectionTrackerInterface *)jarg1;
99410 }
99411
99412 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
99413     return (Dali::BaseHandle *)jarg1;
99414 }
99415
99416 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
99417     return (Dali::BaseHandle *)jarg1;
99418 }
99419
99420 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
99421     return (Dali::BaseHandle *)jarg1;
99422 }
99423
99424 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
99425     return (Dali::BaseHandle *)jarg1;
99426 }
99427
99428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
99429     return (Dali::BaseHandle *)jarg1;
99430 }
99431
99432 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
99433     return (Dali::BaseHandle *)jarg1;
99434 }
99435
99436 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
99437     return (Dali::BaseHandle *)jarg1;
99438 }
99439
99440 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
99441     return (Dali::BaseHandle *)jarg1;
99442 }
99443
99444 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
99445     return (Dali::BaseHandle *)jarg1;
99446 }
99447
99448 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
99449     return (Dali::BaseHandle *)jarg1;
99450 }
99451
99452 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
99453     return (Dali::BaseHandle *)jarg1;
99454 }
99455
99456 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
99457     return (Dali::BaseHandle *)jarg1;
99458 }
99459
99460 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
99461     return (Dali::BaseHandle *)jarg1;
99462 }
99463
99464 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
99465     return (Dali::Handle *)jarg1;
99466 }
99467
99468 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
99469     return (Dali::Handle *)jarg1;
99470 }
99471
99472 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
99473     return (Dali::BaseHandle *)jarg1;
99474 }
99475
99476 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
99477     return (Dali::BaseHandle *)jarg1;
99478 }
99479
99480 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
99481     return (Dali::Handle *)jarg1;
99482 }
99483
99484 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
99485     return (Dali::BaseHandle *)jarg1;
99486 }
99487
99488 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
99489     return (Dali::Handle *)jarg1;
99490 }
99491
99492 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
99493     return (Dali::GestureDetector *)jarg1;
99494 }
99495
99496 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
99497     return (Dali::Gesture *)jarg1;
99498 }
99499
99500 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
99501     return (Dali::Handle *)jarg1;
99502 }
99503
99504 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
99505     return (Dali::Actor *)jarg1;
99506 }
99507
99508 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
99509     return (Dali::BaseHandle *)jarg1;
99510 }
99511
99512 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
99513     return (Dali::RefObject *)jarg1;
99514 }
99515
99516 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
99517     return (Dali::Actor *)jarg1;
99518 }
99519
99520 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
99521     return (Dali::GestureDetector *)jarg1;
99522 }
99523
99524 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
99525     return (Dali::Gesture *)jarg1;
99526 }
99527
99528 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
99529     return (Dali::GestureDetector *)jarg1;
99530 }
99531
99532 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
99533     return (Dali::Gesture *)jarg1;
99534 }
99535
99536 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
99537     return (Dali::GestureDetector *)jarg1;
99538 }
99539
99540 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
99541     return (Dali::Gesture *)jarg1;
99542 }
99543
99544 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
99545     return (Dali::BaseHandle *)jarg1;
99546 }
99547
99548 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
99549     return (Dali::Handle *)jarg1;
99550 }
99551
99552 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
99553     return (Dali::Handle *)jarg1;
99554 }
99555
99556 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
99557     return (Dali::Handle *)jarg1;
99558 }
99559
99560 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
99561     return (Dali::Image *)jarg1;
99562 }
99563
99564 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
99565     return (Dali::Image *)jarg1;
99566 }
99567
99568 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
99569     return (Dali::Image *)jarg1;
99570 }
99571
99572 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
99573     return (Dali::RefObject *)jarg1;
99574 }
99575
99576 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
99577     return (Dali::Image *)jarg1;
99578 }
99579
99580 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
99581     return (Dali::Image *)jarg1;
99582 }
99583
99584 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
99585     return (Dali::ResourceImage *)jarg1;
99586 }
99587
99588 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
99589     return (Dali::Actor *)jarg1;
99590 }
99591
99592 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
99593     return (Dali::BaseHandle *)jarg1;
99594 }
99595
99596 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
99597     return (Dali::BaseHandle *)jarg1;
99598 }
99599
99600 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
99601     return (Dali::BaseHandle *)jarg1;
99602 }
99603
99604 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
99605     return (Dali::CustomActorImpl *)jarg1;
99606 }
99607
99608 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
99609     return (Dali::CustomActor *)jarg1;
99610 }
99611
99612 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
99613     return (Dali::BaseHandle *)jarg1;
99614 }
99615
99616 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
99617     return (Dali::Toolkit::Control *)jarg1;
99618 }
99619
99620 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
99621     return (Dali::Toolkit::Control *)jarg1;
99622 }
99623
99624 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
99625     return (Dali::Toolkit::Button *)jarg1;
99626 }
99627
99628 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
99629     return (Dali::Toolkit::Button *)jarg1;
99630 }
99631
99632 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
99633     return (Dali::Toolkit::Button *)jarg1;
99634 }
99635
99636 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
99637     return (Dali::Toolkit::Control *)jarg1;
99638 }
99639
99640 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
99641     return (Dali::Toolkit::Control *)jarg1;
99642 }
99643
99644 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
99645     return (Dali::Toolkit::Control *)jarg1;
99646 }
99647
99648 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
99649     return (Dali::Toolkit::Control *)jarg1;
99650 }
99651
99652 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
99653     return (Dali::Toolkit::Control *)jarg1;
99654 }
99655
99656 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
99657     return (Dali::RefObject *)jarg1;
99658 }
99659
99660 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
99661     return (Dali::Toolkit::Scrollable *)jarg1;
99662 }
99663
99664 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
99665     return (Dali::BaseHandle *)jarg1;
99666 }
99667
99668 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
99669     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
99670 }
99671
99672 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
99673     return (Dali::RefObject *)jarg1;
99674 }
99675
99676 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
99677     return (Dali::Toolkit::Ruler *)jarg1;
99678 }
99679
99680 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
99681     return (Dali::Toolkit::Ruler *)jarg1;
99682 }
99683
99684 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
99685     return (Dali::Toolkit::Scrollable *)jarg1;
99686 }
99687
99688 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
99689     return (Dali::Toolkit::Control *)jarg1;
99690 }
99691
99692
99693 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
99694     return (Dali::Toolkit::Control *)jarg1;
99695 }
99696
99697 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
99698     return (Dali::BaseHandle *)jarg1;
99699 }
99700
99701 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
99702     return (Dali::BaseHandle *)jarg1;
99703 }
99704
99705 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
99706     return (Dali::Toolkit::Control *)jarg1;
99707 }
99708
99709 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
99710     return (Dali::Toolkit::Control *)jarg1;
99711 }
99712
99713 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
99714     return (Dali::Toolkit::Control *)jarg1;
99715 }
99716
99717 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
99718     return (Dali::Toolkit::Control *)jarg1;
99719 }
99720
99721 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
99722     return (Dali::Toolkit::Control *)jarg1;
99723 }
99724
99725 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
99726     return (Dali::Toolkit::Control *)jarg1;
99727 }
99728
99729 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
99730     return (Dali::Toolkit::PageTurnView *)jarg1;
99731 }
99732
99733 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
99734     return (Dali::Toolkit::PageTurnView *)jarg1;
99735 }
99736
99737 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
99738     return (Dali::Toolkit::Button *)jarg1;
99739 }
99740
99741 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
99742     return (Dali::BaseHandle *)jarg1;
99743 }
99744
99745 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
99746     return (Dali::BaseHandle *)jarg1;
99747 }
99748
99749 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
99750     return (Dali::BaseHandle *)jarg1;
99751 }
99752
99753 /*
99754  * Widget binding
99755  */
99756 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
99757     return (Dali::BaseHandle *)jarg1;
99758 }
99759
99760 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
99761     return (Dali::BaseObject *)jarg1;
99762 }
99763
99764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
99765   void * jresult ;
99766   Dali::Widget result;
99767
99768   {
99769     try {
99770       result = Dali::Widget::New();
99771     } catch (std::out_of_range& e) {
99772       {
99773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99774       };
99775     } catch (std::exception& e) {
99776       {
99777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99778       };
99779     } catch (...) {
99780       {
99781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99782       };
99783     }
99784   }
99785   jresult = new Dali::Widget((const Dali::Widget &)result);
99786   return jresult;
99787 }
99788
99789
99790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
99791   void * jresult ;
99792   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
99793   Dali::Widget result;
99794
99795   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99796
99797   if (!arg1) {
99798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
99799     return 0;
99800   }
99801   {
99802     try {
99803       jresult = new Dali::Widget(arg1);
99804     } catch (std::out_of_range& e) {
99805       {
99806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99807       };
99808     } catch (std::exception& e) {
99809       {
99810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99811       };
99812     } catch (...) {
99813       {
99814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99815       };
99816     }
99817   }
99818   return jresult;
99819 }
99820
99821
99822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
99823   void * jresult ;
99824   Dali::Widget *result = 0 ;
99825
99826   {
99827     try {
99828       result = (Dali::Widget *)new Dali::Widget();
99829     } catch (std::out_of_range& e) {
99830       {
99831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99832       };
99833     } catch (std::exception& e) {
99834       {
99835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99836       };
99837     } catch (...) {
99838       {
99839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99840       };
99841     }
99842   }
99843   jresult = (void *)result;
99844   return jresult;
99845 }
99846
99847
99848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
99849   void * jresult ;
99850   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
99851   Dali::Widget *arg2 = 0 ;
99852   Dali::Widget *result = 0 ;
99853
99854   arg1 = (Dali::Widget *)jarg1;
99855   arg2 = (Dali::Widget *)jarg2;
99856   if (!arg2) {
99857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
99858     return 0;
99859   }
99860   {
99861     try {
99862       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
99863     } catch (std::out_of_range& e) {
99864       {
99865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99866       };
99867     } catch (std::exception& e) {
99868       {
99869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99870       };
99871     } catch (...) {
99872       {
99873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99874       };
99875     }
99876   }
99877   jresult = (void *)result;
99878   return jresult;
99879 }
99880
99881
99882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
99883   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
99884
99885   arg1 = (Dali::Widget *)jarg1;
99886   {
99887     try {
99888       delete arg1;
99889     } catch (std::out_of_range& e) {
99890       {
99891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99892       };
99893     } catch (std::exception& e) {
99894       {
99895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99896       };
99897     } catch (...) {
99898       {
99899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99900       };
99901     }
99902   }
99903 }
99904
99905
99906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
99907   void * jresult ;
99908   SwigDirector_WidgetImpl* result;
99909   {
99910     try {
99911       result = new SwigDirector_WidgetImpl();
99912     } catch (std::out_of_range& e) {
99913       {
99914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99915       };
99916     } catch (std::exception& e) {
99917       {
99918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99919       };
99920     } catch (...) {
99921       {
99922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99923       };
99924     }
99925   }
99926   jresult = result;
99927   return jresult;
99928 }
99929
99930
99931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
99932   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99933   std::string *arg2 = 0 ;
99934   Dali::Window arg3 ;
99935   Dali::Window *argp3 ;
99936
99937   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99938   if (!jarg2) {
99939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99940     return ;
99941   }
99942   std::string arg2_str(jarg2);
99943   arg2 = &arg2_str;
99944   argp3 = (Dali::Window *)jarg3;
99945   if (!argp3) {
99946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99947     return ;
99948   }
99949   arg3 = *argp3;
99950   {
99951     try {
99952       (arg1)->OnCreate((std::string const &)*arg2,arg3);
99953     } catch (std::out_of_range& e) {
99954       {
99955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99956       };
99957     } catch (std::exception& e) {
99958       {
99959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99960       };
99961     } catch (...) {
99962       {
99963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99964       };
99965     }
99966   }
99967 }
99968
99969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
99970   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99971   std::string *arg2 = 0 ;
99972   Dali::Window arg3 ;
99973   Dali::Window *argp3 ;
99974
99975   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99976   if (!jarg2) {
99977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99978     return ;
99979   }
99980   std::string arg2_str(jarg2);
99981   arg2 = &arg2_str;
99982   argp3 = (Dali::Window *)jarg3;
99983   if (!argp3) {
99984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99985     return ;
99986   }
99987   arg3 = *argp3;
99988   {
99989     try {
99990       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
99991     } catch (std::out_of_range& e) {
99992       {
99993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99994       };
99995     } catch (std::exception& e) {
99996       {
99997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99998       };
99999     } catch (...) {
100000       {
100001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100002       };
100003     }
100004   }
100005 }
100006
100007
100008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100009   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100010   std::string *arg2 = 0 ;
100011   Dali::Widget::Termination arg3 ;
100012
100013   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100014   if (!jarg2) {
100015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100016     return ;
100017   }
100018   std::string arg2_str(jarg2);
100019   arg2 = &arg2_str;
100020   arg3 = (Dali::Widget::Termination)jarg3;
100021   {
100022     try {
100023       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100024     } catch (std::out_of_range& e) {
100025       {
100026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100027       };
100028     } catch (std::exception& e) {
100029       {
100030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100031       };
100032     } catch (...) {
100033       {
100034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100035       };
100036     }
100037   }
100038 }
100039
100040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100041   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100042   std::string *arg2 = 0 ;
100043   Dali::Widget::Termination arg3 ;
100044
100045   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100046   if (!jarg2) {
100047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100048     return ;
100049   }
100050   std::string arg2_str(jarg2);
100051   arg2 = &arg2_str;
100052   arg3 = (Dali::Widget::Termination)jarg3;
100053   {
100054     try {
100055       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
100056     } catch (std::out_of_range& e) {
100057       {
100058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100059       };
100060     } catch (std::exception& e) {
100061       {
100062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100063       };
100064     } catch (...) {
100065       {
100066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100067       };
100068     }
100069   }
100070 }
100071
100072
100073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
100074   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100075
100076   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100077   {
100078     try {
100079       (arg1)->OnPause();
100080     } catch (std::out_of_range& e) {
100081       {
100082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100083       };
100084     } catch (std::exception& e) {
100085       {
100086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100087       };
100088     } catch (...) {
100089       {
100090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100091       };
100092     }
100093   }
100094 }
100095
100096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
100097   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100098
100099   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100100   {
100101     try {
100102       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
100103     } catch (std::out_of_range& e) {
100104       {
100105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100106       };
100107     } catch (std::exception& e) {
100108       {
100109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100110       };
100111     } catch (...) {
100112       {
100113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100114       };
100115     }
100116   }
100117 }
100118
100119
100120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
100121   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100122
100123   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100124   {
100125     try {
100126       (arg1)->OnResume();
100127     } catch (std::out_of_range& e) {
100128       {
100129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100130       };
100131     } catch (std::exception& e) {
100132       {
100133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100134       };
100135     } catch (...) {
100136       {
100137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100138       };
100139     }
100140   }
100141 }
100142
100143
100144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
100145   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100146
100147   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100148   {
100149     try {
100150       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
100151     } catch (std::out_of_range& e) {
100152       {
100153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100154       };
100155     } catch (std::exception& e) {
100156       {
100157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100158       };
100159     } catch (...) {
100160       {
100161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100162       };
100163     }
100164   }
100165 }
100166
100167
100168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
100169   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100170   Dali::Window arg2 ;
100171   Dali::Window *argp2 ;
100172
100173   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100174   argp2 = (Dali::Window *)jarg2;
100175   if (!argp2) {
100176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100177     return ;
100178   }
100179   arg2 = *argp2;
100180   {
100181     try {
100182       (arg1)->OnResize(arg2);
100183     } catch (std::out_of_range& e) {
100184       {
100185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100186       };
100187     } catch (std::exception& e) {
100188       {
100189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100190       };
100191     } catch (...) {
100192       {
100193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100194       };
100195     }
100196   }
100197 }
100198
100199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
100200   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100201   Dali::Window arg2 ;
100202   Dali::Window *argp2 ;
100203
100204   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100205   argp2 = (Dali::Window *)jarg2;
100206   if (!argp2) {
100207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100208     return ;
100209   }
100210   arg2 = *argp2;
100211   {
100212     try {
100213       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
100214     } catch (std::out_of_range& e) {
100215       {
100216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100217       };
100218     } catch (std::exception& e) {
100219       {
100220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100221       };
100222     } catch (...) {
100223       {
100224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100225       };
100226     }
100227   }
100228 }
100229
100230
100231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
100232   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100233   std::string *arg2 = 0 ;
100234   int arg3 ;
100235
100236   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100237   if (!jarg2) {
100238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100239     return ;
100240   }
100241   std::string arg2_str(jarg2);
100242   arg2 = &arg2_str;
100243   arg3 = (int)jarg3;
100244   {
100245     try {
100246       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
100247     } catch (std::out_of_range& e) {
100248       {
100249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100250       };
100251     } catch (std::exception& e) {
100252       {
100253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100254       };
100255     } catch (...) {
100256       {
100257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100258       };
100259     }
100260   }
100261 }
100262
100263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100264   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100265   std::string *arg2 = 0 ;
100266   int arg3 ;
100267
100268   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100269   if (!jarg2) {
100270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100271     return ;
100272   }
100273   std::string arg2_str(jarg2);
100274   arg2 = &arg2_str;
100275   arg3 = (int)jarg3;
100276   {
100277     try {
100278       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
100279     } catch (std::out_of_range& e) {
100280       {
100281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100282       };
100283     } catch (std::exception& e) {
100284       {
100285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100286       };
100287     } catch (...) {
100288       {
100289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100290       };
100291     }
100292   }
100293 }
100294
100295
100296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
100297   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100298   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100299   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100300
100301   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100302   arg2 = (Dali::SlotObserver *)jarg2;
100303   arg3 = (Dali::CallbackBase *)jarg3;
100304   {
100305     try {
100306       (arg1)->SignalConnected(arg2,arg3);
100307     } catch (std::out_of_range& e) {
100308       {
100309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100310       };
100311     } catch (std::exception& e) {
100312       {
100313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100314       };
100315     } catch (...) {
100316       {
100317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100318       };
100319     }
100320   }
100321 }
100322
100323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100324   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100325   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100326   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100327
100328   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100329   arg2 = (Dali::SlotObserver *)jarg2;
100330   arg3 = (Dali::CallbackBase *)jarg3;
100331   {
100332     try {
100333       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
100334     } catch (std::out_of_range& e) {
100335       {
100336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100337       };
100338     } catch (std::exception& e) {
100339       {
100340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100341       };
100342     } catch (...) {
100343       {
100344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100345       };
100346     }
100347   }
100348 }
100349
100350
100351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
100352   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100353   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100354   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100355
100356   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100357   arg2 = (Dali::SlotObserver *)jarg2;
100358   arg3 = (Dali::CallbackBase *)jarg3;
100359   {
100360     try {
100361       (arg1)->SignalDisconnected(arg2,arg3);
100362     } catch (std::out_of_range& e) {
100363       {
100364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100365       };
100366     } catch (std::exception& e) {
100367       {
100368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100369       };
100370     } catch (...) {
100371       {
100372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100373       };
100374     }
100375   }
100376 }
100377
100378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
100379   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100380   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
100381   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
100382
100383   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100384   arg2 = (Dali::SlotObserver *)jarg2;
100385   arg3 = (Dali::CallbackBase *)jarg3;
100386   {
100387     try {
100388       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
100389     } catch (std::out_of_range& e) {
100390       {
100391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100392       };
100393     } catch (std::exception& e) {
100394       {
100395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100396       };
100397     } catch (...) {
100398       {
100399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100400       };
100401     }
100402   }
100403 }
100404
100405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
100406   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100407   std::string *arg2 = 0 ;
100408
100409   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100410   if (!jarg2) {
100411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100412     return ;
100413   }
100414   std::string arg2_str(jarg2);
100415   arg2 = &arg2_str;
100416   {
100417     try {
100418       (arg1)->SetContentInfo((std::string const &)*arg2);
100419     } catch (std::out_of_range& e) {
100420       {
100421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100422       };
100423     } catch (std::exception& e) {
100424       {
100425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100426       };
100427     } catch (...) {
100428       {
100429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100430       };
100431     }
100432   }
100433 }
100434
100435
100436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
100437   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100438   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
100439
100440   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100441   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
100442   {
100443     try {
100444       (arg1)->SetImpl(arg2);
100445     } catch (std::out_of_range& e) {
100446       {
100447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100448       };
100449     } catch (std::exception& e) {
100450       {
100451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100452       };
100453     } catch (...) {
100454       {
100455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100456       };
100457     }
100458   }
100459 }
100460
100461 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) {
100462
100463   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
100464   if (director) {
100465     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
100466   }
100467 }
100468
100469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
100470   void * jresult ;
100471   Dali::Widget *arg1 = 0 ;
100472   SwigDirector_WidgetImpl *result = 0 ;
100473
100474   arg1 = (Dali::Widget *)jarg1;
100475   if (!arg1) {
100476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
100477     return 0;
100478   }
100479   {
100480     try {
100481       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
100482     } catch (std::out_of_range& e) {
100483       {
100484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100485       };
100486     } catch (std::exception& e) {
100487       {
100488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100489       };
100490     } catch (...) {
100491       {
100492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100493       };
100494     }
100495   }
100496
100497   jresult = (void *)result;
100498   return jresult;
100499 }
100500
100501
100502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
100503   void * jresult ;
100504   int *arg1 = (int *) 0 ;
100505   char ***arg2 ;
100506   std::string *arg3 = 0 ;
100507   Dali::WidgetApplication result;
100508   {
100509     int index = 0;
100510     int length = 0;
100511     char *retPtr;
100512     char *nextPtr;
100513     argWidgetC = jarg1;
100514     argWidgetV = new char*[jarg1 + 1];
100515
100516     retPtr = strtok_r( jarg2, " ", &nextPtr);
100517     if( retPtr )
100518     {
100519       length = strlen(retPtr);
100520     }
100521     argWidgetV[index] = new char[length + 1];
100522     if( retPtr )
100523     {
100524       strncpy(argWidgetV[index], retPtr, length);
100525     }
100526     argWidgetV[index][length] = '\0';
100527     index++;
100528
100529     while (index < jarg1)
100530     {
100531       length = 0;
100532       retPtr = strtok_r(NULL, " ", &nextPtr);
100533       if( retPtr )
100534       {
100535         length = strlen(retPtr);
100536       }
100537       argWidgetV[index] = new char[length + 1];
100538       if( retPtr )
100539       {
100540         strncpy(argWidgetV[index], retPtr, length);
100541       }
100542       argWidgetV[index][length] = '\0';
100543       index++;
100544     }
100545
100546     argWidgetV[jarg1] = NULL;
100547     argWidgetC = jarg1;
100548
100549     arg1 = &argWidgetC;
100550     arg2 = &argWidgetV;
100551   }
100552
100553   if (!jarg3) {
100554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100555     return 0;
100556   }
100557   std::string arg3_str(jarg3);
100558   arg3 = &arg3_str;
100559   {
100560     try {
100561       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
100562     } catch (std::out_of_range& e) {
100563       {
100564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100565       };
100566     } catch (std::exception& e) {
100567       {
100568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100569       };
100570     } catch (...) {
100571       {
100572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100573       };
100574     }
100575   }
100576   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
100577
100578   return jresult;
100579 }
100580
100581
100582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
100583   void * jresult ;
100584   Dali::WidgetApplication *result = 0 ;
100585
100586   {
100587     try {
100588       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
100589     } catch (std::out_of_range& e) {
100590       {
100591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100592       };
100593     } catch (std::exception& e) {
100594       {
100595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100596       };
100597     } catch (...) {
100598       {
100599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100600       };
100601     }
100602   }
100603   jresult = (void *)result;
100604   return jresult;
100605 }
100606
100607
100608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
100609   void * jresult ;
100610   Dali::WidgetApplication *arg1 = 0 ;
100611   Dali::WidgetApplication *result = 0 ;
100612
100613   arg1 = (Dali::WidgetApplication *)jarg1;
100614   if (!arg1) {
100615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100616     return 0;
100617   }
100618   {
100619     try {
100620       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
100621     } catch (std::out_of_range& e) {
100622       {
100623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100624       };
100625     } catch (std::exception& e) {
100626       {
100627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100628       };
100629     } catch (...) {
100630       {
100631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100632       };
100633     }
100634   }
100635   jresult = (void *)result;
100636   return jresult;
100637 }
100638
100639
100640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
100641   void * jresult ;
100642   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100643   Dali::WidgetApplication *arg2 = 0 ;
100644   Dali::WidgetApplication *result = 0 ;
100645
100646   arg1 = (Dali::WidgetApplication *)jarg1;
100647   arg2 = (Dali::WidgetApplication *)jarg2;
100648   if (!arg2) {
100649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
100650     return 0;
100651   }
100652   {
100653     try {
100654       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
100655     } catch (std::out_of_range& e) {
100656       {
100657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100658       };
100659     } catch (std::exception& e) {
100660       {
100661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100662       };
100663     } catch (...) {
100664       {
100665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100666       };
100667     }
100668   }
100669   jresult = (void *)result;
100670   return jresult;
100671 }
100672
100673
100674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
100675   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100676
100677   arg1 = (Dali::WidgetApplication *)jarg1;
100678   {
100679     try {
100680       delete arg1;
100681       if( argWidgetV )
100682       {
100683         // free string data
100684         for( int i=0; i < argWidgetC+1; i++)
100685         {
100686           delete [] argWidgetV[i];
100687         }
100688         delete [] argWidgetV;
100689       }
100690     } catch (std::out_of_range& e) {
100691       {
100692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100693       };
100694     } catch (std::exception& e) {
100695       {
100696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100697       };
100698     } catch (...) {
100699       {
100700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100701       };
100702     }
100703   }
100704 }
100705
100706
100707 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
100708 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
100709
100710 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
100711 {
100712   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
100713   return *widget;
100714 }
100715
100716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
100717   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
100718   std::string *arg2 = 0 ;
100719
100720   arg1 = (Dali::WidgetApplication *)jarg1;
100721   if (!jarg2) {
100722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100723     return ;
100724   }
100725   std::string arg2_str(*jarg2);
100726   arg2 = &arg2_str;
100727
100728   if(!_CSharpCreateWidgetFunction)
100729   {
100730     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
100731   }
100732
100733   {
100734     try {
100735       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
100736     } catch (std::out_of_range& e) {
100737       {
100738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100739       };
100740     } catch (std::exception& e) {
100741       {
100742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100743       };
100744     } catch (...) {
100745       {
100746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100747       };
100748     }
100749   }
100750
100751   //Typemap argout in c++ file.
100752   //This will convert c++ string to c# string
100753   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
100754 }
100755
100756
100757 //for PixelBuffer and ImageLoading
100758
100759 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
100760     return (Dali::BaseHandle *)jarg1;
100761 }
100762
100763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
100764   void * jresult ;
100765   unsigned int arg1 ;
100766   unsigned int arg2 ;
100767   Dali::Pixel::Format arg3 ;
100768   Dali::Devel::PixelBuffer result;
100769
100770   arg1 = (unsigned int)jarg1;
100771   arg2 = (unsigned int)jarg2;
100772   arg3 = (Dali::Pixel::Format)jarg3;
100773   {
100774     try {
100775       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
100776     } catch (std::out_of_range& e) {
100777       {
100778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100779       };
100780     } catch (std::exception& e) {
100781       {
100782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100783       };
100784     } catch (...) {
100785       {
100786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100787       };
100788     }
100789   }
100790   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100791   return jresult;
100792 }
100793
100794
100795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
100796   void * jresult ;
100797   Dali::Devel::PixelBuffer *result = 0 ;
100798
100799   {
100800     try {
100801       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
100802     } catch (std::out_of_range& e) {
100803       {
100804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100805       };
100806     } catch (std::exception& e) {
100807       {
100808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100809       };
100810     } catch (...) {
100811       {
100812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100813       };
100814     }
100815   }
100816   jresult = (void *)result;
100817   return jresult;
100818 }
100819
100820
100821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
100822   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100823
100824   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100825   {
100826     try {
100827       delete arg1;
100828     } catch (std::out_of_range& e) {
100829       {
100830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100831       };
100832     } catch (std::exception& e) {
100833       {
100834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100835       };
100836     } catch (...) {
100837       {
100838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100839       };
100840     }
100841   }
100842 }
100843
100844
100845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
100846   void * jresult ;
100847   Dali::Devel::PixelBuffer *arg1 = 0 ;
100848   Dali::Devel::PixelBuffer *result = 0 ;
100849
100850   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100851   if (!arg1) {
100852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
100853     return 0;
100854   }
100855   {
100856     try {
100857       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
100858     } catch (std::out_of_range& e) {
100859       {
100860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100861       };
100862     } catch (std::exception& e) {
100863       {
100864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100865       };
100866     } catch (...) {
100867       {
100868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100869       };
100870     }
100871   }
100872   jresult = (void *)result;
100873   return jresult;
100874 }
100875
100876
100877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
100878   void * jresult ;
100879   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100880   Dali::Devel::PixelBuffer *arg2 = 0 ;
100881   Dali::Devel::PixelBuffer *result = 0 ;
100882
100883   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100884   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
100885   if (!arg2) {
100886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
100887     return 0;
100888   }
100889   {
100890     try {
100891       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
100892     } catch (std::out_of_range& e) {
100893       {
100894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100895       };
100896     } catch (std::exception& e) {
100897       {
100898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100899       };
100900     } catch (...) {
100901       {
100902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100903       };
100904     }
100905   }
100906   jresult = (void *)result;
100907   return jresult;
100908 }
100909
100910
100911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
100912   void * jresult ;
100913   Dali::Devel::PixelBuffer *arg1 = 0 ;
100914   Dali::PixelData result;
100915
100916   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100917   if (!arg1) {
100918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
100919     return 0;
100920   }
100921   {
100922     try {
100923       result = Dali::Devel::PixelBuffer::Convert(*arg1);
100924     } catch (std::out_of_range& e) {
100925       {
100926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100927       };
100928     } catch (std::exception& e) {
100929       {
100930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100931       };
100932     } catch (...) {
100933       {
100934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100935       };
100936     }
100937   }
100938   jresult = new Dali::PixelData((const Dali::PixelData &)result);
100939   return jresult;
100940 }
100941
100942
100943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
100944   void * jresult ;
100945   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100946   Dali::PixelData result;
100947
100948   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100949   {
100950     try {
100951       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
100952     } catch (std::out_of_range& e) {
100953       {
100954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100955       };
100956     } catch (std::exception& e) {
100957       {
100958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100959       };
100960     } catch (...) {
100961       {
100962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100963       };
100964     }
100965   }
100966   jresult = new Dali::PixelData((const Dali::PixelData &)result);
100967   return jresult;
100968 }
100969
100970
100971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
100972   void * jresult ;
100973   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100974   unsigned char *result = 0 ;
100975
100976   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100977   {
100978     try {
100979       result = (unsigned char *)(arg1)->GetBuffer();
100980     } catch (std::out_of_range& e) {
100981       {
100982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100983       };
100984     } catch (std::exception& e) {
100985       {
100986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100987       };
100988     } catch (...) {
100989       {
100990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100991       };
100992     }
100993   }
100994   jresult = (void *)result;
100995   return jresult;
100996 }
100997
100998
100999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101000   unsigned int jresult ;
101001   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101002   unsigned int result;
101003
101004   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101005   {
101006     try {
101007       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101008     } catch (std::out_of_range& e) {
101009       {
101010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101011       };
101012     } catch (std::exception& e) {
101013       {
101014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101015       };
101016     } catch (...) {
101017       {
101018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101019       };
101020     }
101021   }
101022   jresult = result;
101023   return jresult;
101024 }
101025
101026
101027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101028   unsigned int jresult ;
101029   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101030   unsigned int result;
101031
101032   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101033   {
101034     try {
101035       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101036     } catch (std::out_of_range& e) {
101037       {
101038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101039       };
101040     } catch (std::exception& e) {
101041       {
101042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101043       };
101044     } catch (...) {
101045       {
101046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101047       };
101048     }
101049   }
101050   jresult = result;
101051   return jresult;
101052 }
101053
101054
101055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101056   int jresult ;
101057   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101058   Dali::Pixel::Format result;
101059
101060   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101061   {
101062     try {
101063       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101064     } catch (std::out_of_range& e) {
101065       {
101066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101067       };
101068     } catch (std::exception& e) {
101069       {
101070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101071       };
101072     } catch (...) {
101073       {
101074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101075       };
101076     }
101077   }
101078   jresult = (int)result;
101079   return jresult;
101080 }
101081
101082
101083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101084   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101085   Dali::Devel::PixelBuffer arg2 ;
101086   float arg3 ;
101087   bool arg4 ;
101088   Dali::Devel::PixelBuffer *argp2 ;
101089
101090   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101091   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101092   if (!argp2) {
101093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101094     return ;
101095   }
101096   arg2 = *argp2;
101097   arg3 = (float)jarg3;
101098   arg4 = jarg4 ? true : false;
101099   {
101100     try {
101101       (arg1)->ApplyMask(arg2,arg3,arg4);
101102     } catch (std::out_of_range& e) {
101103       {
101104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101105       };
101106     } catch (std::exception& e) {
101107       {
101108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101109       };
101110     } catch (...) {
101111       {
101112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101113       };
101114     }
101115   }
101116 }
101117
101118
101119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
101120   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101121   Dali::Devel::PixelBuffer arg2 ;
101122   float arg3 ;
101123   Dali::Devel::PixelBuffer *argp2 ;
101124
101125   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101126   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101127   if (!argp2) {
101128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101129     return ;
101130   }
101131   arg2 = *argp2;
101132   arg3 = (float)jarg3;
101133   {
101134     try {
101135       (arg1)->ApplyMask(arg2,arg3);
101136     } catch (std::out_of_range& e) {
101137       {
101138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101139       };
101140     } catch (std::exception& e) {
101141       {
101142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101143       };
101144     } catch (...) {
101145       {
101146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101147       };
101148     }
101149   }
101150 }
101151
101152
101153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
101154   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101155   Dali::Devel::PixelBuffer arg2 ;
101156   Dali::Devel::PixelBuffer *argp2 ;
101157
101158   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101159   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101160   if (!argp2) {
101161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101162     return ;
101163   }
101164   arg2 = *argp2;
101165   {
101166     try {
101167       (arg1)->ApplyMask(arg2);
101168     } catch (std::out_of_range& e) {
101169       {
101170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101171       };
101172     } catch (std::exception& e) {
101173       {
101174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101175       };
101176     } catch (...) {
101177       {
101178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101179       };
101180     }
101181   }
101182 }
101183
101184
101185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
101186   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101187   float arg2 ;
101188
101189   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101190   arg2 = (float)jarg2;
101191   {
101192     try {
101193       (arg1)->ApplyGaussianBlur(arg2);
101194     } catch (std::out_of_range& e) {
101195       {
101196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101197       };
101198     } catch (std::exception& e) {
101199       {
101200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101201       };
101202     } catch (...) {
101203       {
101204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101205       };
101206     }
101207   }
101208 }
101209
101210
101211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
101212   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101213   uint16_t arg2 ;
101214   uint16_t arg3 ;
101215   uint16_t arg4 ;
101216   uint16_t arg5 ;
101217
101218   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101219   arg2 = (uint16_t)jarg2;
101220   arg3 = (uint16_t)jarg3;
101221   arg4 = (uint16_t)jarg4;
101222   arg5 = (uint16_t)jarg5;
101223   {
101224     try {
101225       (arg1)->Crop(arg2,arg3,arg4,arg5);
101226     } catch (std::out_of_range& e) {
101227       {
101228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101229       };
101230     } catch (std::exception& e) {
101231       {
101232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101233       };
101234     } catch (...) {
101235       {
101236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101237       };
101238     }
101239   }
101240 }
101241
101242
101243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
101244   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101245   uint16_t arg2 ;
101246   uint16_t arg3 ;
101247
101248   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101249   arg2 = (uint16_t)jarg2;
101250   arg3 = (uint16_t)jarg3;
101251   {
101252     try {
101253       (arg1)->Resize(arg2,arg3);
101254     } catch (std::out_of_range& e) {
101255       {
101256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101257       };
101258     } catch (std::exception& e) {
101259       {
101260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101261       };
101262     } catch (...) {
101263       {
101264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101265       };
101266     }
101267   }
101268 }
101269
101270
101271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101272   void * jresult ;
101273   std::string *arg1 = 0 ;
101274   Dali::ImageDimensions arg2 ;
101275   Dali::FittingMode::Type arg3 ;
101276   Dali::SamplingMode::Type arg4 ;
101277   bool arg5 ;
101278   Dali::ImageDimensions *argp2 ;
101279   Dali::Devel::PixelBuffer result;
101280
101281   if (!jarg1) {
101282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101283     return 0;
101284   }
101285   std::string arg1_str(jarg1);
101286   arg1 = &arg1_str;
101287   argp2 = (Dali::ImageDimensions *)jarg2;
101288   if (!argp2) {
101289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101290     return 0;
101291   }
101292   arg2 = *argp2;
101293   arg3 = (Dali::FittingMode::Type)jarg3;
101294   arg4 = (Dali::SamplingMode::Type)jarg4;
101295   arg5 = jarg5 ? true : false;
101296   {
101297     try {
101298       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101299     } catch (std::out_of_range& e) {
101300       {
101301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101302       };
101303     } catch (std::exception& e) {
101304       {
101305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101306       };
101307     } catch (...) {
101308       {
101309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101310       };
101311     }
101312   }
101313   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101314
101315   return jresult;
101316 }
101317
101318
101319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101320   void * jresult ;
101321   std::string *arg1 = 0 ;
101322   Dali::ImageDimensions arg2 ;
101323   Dali::FittingMode::Type arg3 ;
101324   Dali::SamplingMode::Type arg4 ;
101325   Dali::ImageDimensions *argp2 ;
101326   Dali::Devel::PixelBuffer result;
101327
101328   if (!jarg1) {
101329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101330     return 0;
101331   }
101332   std::string arg1_str(jarg1);
101333   arg1 = &arg1_str;
101334   argp2 = (Dali::ImageDimensions *)jarg2;
101335   if (!argp2) {
101336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101337     return 0;
101338   }
101339   arg2 = *argp2;
101340   arg3 = (Dali::FittingMode::Type)jarg3;
101341   arg4 = (Dali::SamplingMode::Type)jarg4;
101342   {
101343     try {
101344       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
101345     } catch (std::out_of_range& e) {
101346       {
101347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101348       };
101349     } catch (std::exception& e) {
101350       {
101351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101352       };
101353     } catch (...) {
101354       {
101355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101356       };
101357     }
101358   }
101359   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101360
101361   return jresult;
101362 }
101363
101364
101365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101366   void * jresult ;
101367   std::string *arg1 = 0 ;
101368   Dali::ImageDimensions arg2 ;
101369   Dali::FittingMode::Type arg3 ;
101370   Dali::ImageDimensions *argp2 ;
101371   Dali::Devel::PixelBuffer result;
101372
101373   if (!jarg1) {
101374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101375     return 0;
101376   }
101377   std::string arg1_str(jarg1);
101378   arg1 = &arg1_str;
101379   argp2 = (Dali::ImageDimensions *)jarg2;
101380   if (!argp2) {
101381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101382     return 0;
101383   }
101384   arg2 = *argp2;
101385   arg3 = (Dali::FittingMode::Type)jarg3;
101386   {
101387     try {
101388       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
101389     } catch (std::out_of_range& e) {
101390       {
101391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101392       };
101393     } catch (std::exception& e) {
101394       {
101395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101396       };
101397     } catch (...) {
101398       {
101399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101400       };
101401     }
101402   }
101403   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101404
101405   return jresult;
101406 }
101407
101408
101409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
101410   void * jresult ;
101411   std::string *arg1 = 0 ;
101412   Dali::ImageDimensions arg2 ;
101413   Dali::ImageDimensions *argp2 ;
101414   Dali::Devel::PixelBuffer result;
101415
101416   if (!jarg1) {
101417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101418     return 0;
101419   }
101420   std::string arg1_str(jarg1);
101421   arg1 = &arg1_str;
101422   argp2 = (Dali::ImageDimensions *)jarg2;
101423   if (!argp2) {
101424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101425     return 0;
101426   }
101427   arg2 = *argp2;
101428   {
101429     try {
101430       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
101431     } catch (std::out_of_range& e) {
101432       {
101433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101434       };
101435     } catch (std::exception& e) {
101436       {
101437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101438       };
101439     } catch (...) {
101440       {
101441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101442       };
101443     }
101444   }
101445   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101446
101447   return jresult;
101448 }
101449
101450
101451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
101452   void * jresult ;
101453   std::string *arg1 = 0 ;
101454   Dali::Devel::PixelBuffer result;
101455
101456   if (!jarg1) {
101457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101458     return 0;
101459   }
101460   std::string arg1_str(jarg1);
101461   arg1 = &arg1_str;
101462   {
101463     try {
101464       result = Dali::LoadImageFromFile((std::string const &)*arg1);
101465     } catch (std::out_of_range& e) {
101466       {
101467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101468       };
101469     } catch (std::exception& e) {
101470       {
101471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101472       };
101473     } catch (...) {
101474       {
101475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101476       };
101477     }
101478   }
101479   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101480
101481   return jresult;
101482 }
101483
101484
101485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101486   void * jresult ;
101487   std::string *arg1 = 0 ;
101488   Dali::ImageDimensions arg2 ;
101489   Dali::FittingMode::Type arg3 ;
101490   Dali::SamplingMode::Type arg4 ;
101491   bool arg5 ;
101492   Dali::ImageDimensions *argp2 ;
101493   Dali::ImageDimensions result;
101494
101495   if (!jarg1) {
101496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101497     return 0;
101498   }
101499   std::string arg1_str(jarg1);
101500   arg1 = &arg1_str;
101501   argp2 = (Dali::ImageDimensions *)jarg2;
101502   if (!argp2) {
101503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101504     return 0;
101505   }
101506   arg2 = *argp2;
101507   arg3 = (Dali::FittingMode::Type)jarg3;
101508   arg4 = (Dali::SamplingMode::Type)jarg4;
101509   arg5 = jarg5 ? true : false;
101510   {
101511     try {
101512       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101513     } catch (std::out_of_range& e) {
101514       {
101515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101516       };
101517     } catch (std::exception& e) {
101518       {
101519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101520       };
101521     } catch (...) {
101522       {
101523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101524       };
101525     }
101526   }
101527   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101528
101529   return jresult;
101530 }
101531
101532
101533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101534   void * jresult ;
101535   std::string *arg1 = 0 ;
101536   Dali::ImageDimensions arg2 ;
101537   Dali::FittingMode::Type arg3 ;
101538   Dali::SamplingMode::Type arg4 ;
101539   Dali::ImageDimensions *argp2 ;
101540   Dali::ImageDimensions result;
101541
101542   if (!jarg1) {
101543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101544     return 0;
101545   }
101546   std::string arg1_str(jarg1);
101547   arg1 = &arg1_str;
101548   argp2 = (Dali::ImageDimensions *)jarg2;
101549   if (!argp2) {
101550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101551     return 0;
101552   }
101553   arg2 = *argp2;
101554   arg3 = (Dali::FittingMode::Type)jarg3;
101555   arg4 = (Dali::SamplingMode::Type)jarg4;
101556   {
101557     try {
101558       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
101559     } catch (std::out_of_range& e) {
101560       {
101561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101562       };
101563     } catch (std::exception& e) {
101564       {
101565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101566       };
101567     } catch (...) {
101568       {
101569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101570       };
101571     }
101572   }
101573   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101574
101575   return jresult;
101576 }
101577
101578
101579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101580   void * jresult ;
101581   std::string *arg1 = 0 ;
101582   Dali::ImageDimensions arg2 ;
101583   Dali::FittingMode::Type arg3 ;
101584   Dali::ImageDimensions *argp2 ;
101585   Dali::ImageDimensions result;
101586
101587   if (!jarg1) {
101588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101589     return 0;
101590   }
101591   std::string arg1_str(jarg1);
101592   arg1 = &arg1_str;
101593   argp2 = (Dali::ImageDimensions *)jarg2;
101594   if (!argp2) {
101595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101596     return 0;
101597   }
101598   arg2 = *argp2;
101599   arg3 = (Dali::FittingMode::Type)jarg3;
101600   {
101601     try {
101602       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
101603     } catch (std::out_of_range& e) {
101604       {
101605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101606       };
101607     } catch (std::exception& e) {
101608       {
101609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101610       };
101611     } catch (...) {
101612       {
101613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101614       };
101615     }
101616   }
101617   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101618
101619   return jresult;
101620 }
101621
101622
101623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
101624   void * jresult ;
101625   std::string *arg1 = 0 ;
101626   Dali::ImageDimensions arg2 ;
101627   Dali::ImageDimensions *argp2 ;
101628   Dali::ImageDimensions result;
101629
101630   if (!jarg1) {
101631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101632     return 0;
101633   }
101634   std::string arg1_str(jarg1);
101635   arg1 = &arg1_str;
101636   argp2 = (Dali::ImageDimensions *)jarg2;
101637   if (!argp2) {
101638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101639     return 0;
101640   }
101641   arg2 = *argp2;
101642   {
101643     try {
101644       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
101645     } catch (std::out_of_range& e) {
101646       {
101647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101648       };
101649     } catch (std::exception& e) {
101650       {
101651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101652       };
101653     } catch (...) {
101654       {
101655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101656       };
101657     }
101658   }
101659   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101660
101661   return jresult;
101662 }
101663
101664
101665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
101666   void * jresult ;
101667   std::string *arg1 = 0 ;
101668   Dali::ImageDimensions result;
101669
101670   if (!jarg1) {
101671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101672     return 0;
101673   }
101674   std::string arg1_str(jarg1);
101675   arg1 = &arg1_str;
101676   {
101677     try {
101678       result = Dali::GetClosestImageSize((std::string const &)*arg1);
101679     } catch (std::out_of_range& e) {
101680       {
101681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101682       };
101683     } catch (std::exception& e) {
101684       {
101685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101686       };
101687     } catch (...) {
101688       {
101689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101690       };
101691     }
101692   }
101693   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101694
101695   return jresult;
101696 }
101697
101698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
101699   void * jresult ;
101700   std::string *arg1 = 0 ;
101701   Dali::ImageDimensions result;
101702
101703   if (!jarg1) {
101704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101705     return 0;
101706   }
101707   std::string arg1_str(jarg1);
101708   arg1 = &arg1_str;
101709   {
101710     try {
101711       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
101712     } catch (std::out_of_range& e) {
101713       {
101714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101715       };
101716     } catch (std::exception& e) {
101717       {
101718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101719       };
101720     } catch (...) {
101721       {
101722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101723       };
101724     }
101725   }
101726   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
101727
101728   return jresult;
101729 }
101730
101731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
101732   void * jresult ;
101733   std::string *arg1 = 0 ;
101734   Dali::ImageDimensions arg2 ;
101735   Dali::FittingMode::Type arg3 ;
101736   Dali::SamplingMode::Type arg4 ;
101737   bool arg5 ;
101738   Dali::ImageDimensions *argp2 ;
101739   Dali::Devel::PixelBuffer result;
101740
101741   if (!jarg1) {
101742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101743     return 0;
101744   }
101745   std::string arg1_str(jarg1);
101746   arg1 = &arg1_str;
101747   argp2 = (Dali::ImageDimensions *)jarg2;
101748   if (!argp2) {
101749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101750     return 0;
101751   }
101752   arg2 = *argp2;
101753   arg3 = (Dali::FittingMode::Type)jarg3;
101754   arg4 = (Dali::SamplingMode::Type)jarg4;
101755   arg5 = jarg5 ? true : false;
101756   {
101757     try {
101758       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
101759     } catch (std::out_of_range& e) {
101760       {
101761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101762       };
101763     } catch (std::exception& e) {
101764       {
101765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101766       };
101767     } catch (...) {
101768       {
101769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101770       };
101771     }
101772   }
101773   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101774
101775   return jresult;
101776 }
101777
101778
101779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
101780   void * jresult ;
101781   std::string *arg1 = 0 ;
101782   Dali::ImageDimensions arg2 ;
101783   Dali::FittingMode::Type arg3 ;
101784   Dali::SamplingMode::Type arg4 ;
101785   Dali::ImageDimensions *argp2 ;
101786   Dali::Devel::PixelBuffer result;
101787
101788   if (!jarg1) {
101789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101790     return 0;
101791   }
101792   std::string arg1_str(jarg1);
101793   arg1 = &arg1_str;
101794   argp2 = (Dali::ImageDimensions *)jarg2;
101795   if (!argp2) {
101796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101797     return 0;
101798   }
101799   arg2 = *argp2;
101800   arg3 = (Dali::FittingMode::Type)jarg3;
101801   arg4 = (Dali::SamplingMode::Type)jarg4;
101802   {
101803     try {
101804       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
101805     } catch (std::out_of_range& e) {
101806       {
101807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101808       };
101809     } catch (std::exception& e) {
101810       {
101811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101812       };
101813     } catch (...) {
101814       {
101815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101816       };
101817     }
101818   }
101819   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101820
101821   return jresult;
101822 }
101823
101824
101825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
101826   void * jresult ;
101827   std::string *arg1 = 0 ;
101828   Dali::ImageDimensions arg2 ;
101829   Dali::FittingMode::Type arg3 ;
101830   Dali::ImageDimensions *argp2 ;
101831   Dali::Devel::PixelBuffer result;
101832
101833   if (!jarg1) {
101834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101835     return 0;
101836   }
101837   std::string arg1_str(jarg1);
101838   arg1 = &arg1_str;
101839   argp2 = (Dali::ImageDimensions *)jarg2;
101840   if (!argp2) {
101841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101842     return 0;
101843   }
101844   arg2 = *argp2;
101845   arg3 = (Dali::FittingMode::Type)jarg3;
101846   {
101847     try {
101848       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
101849     } catch (std::out_of_range& e) {
101850       {
101851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101852       };
101853     } catch (std::exception& e) {
101854       {
101855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101856       };
101857     } catch (...) {
101858       {
101859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101860       };
101861     }
101862   }
101863   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101864
101865   return jresult;
101866 }
101867
101868
101869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
101870   void * jresult ;
101871   std::string *arg1 = 0 ;
101872   Dali::ImageDimensions arg2 ;
101873   Dali::ImageDimensions *argp2 ;
101874   Dali::Devel::PixelBuffer result;
101875
101876   if (!jarg1) {
101877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101878     return 0;
101879   }
101880   std::string arg1_str(jarg1);
101881   arg1 = &arg1_str;
101882   argp2 = (Dali::ImageDimensions *)jarg2;
101883   if (!argp2) {
101884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
101885     return 0;
101886   }
101887   arg2 = *argp2;
101888   {
101889     try {
101890       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
101891     } catch (std::out_of_range& e) {
101892       {
101893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101894       };
101895     } catch (std::exception& e) {
101896       {
101897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101898       };
101899     } catch (...) {
101900       {
101901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101902       };
101903     }
101904   }
101905   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101906
101907   return jresult;
101908 }
101909
101910
101911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
101912   void * jresult ;
101913   std::string *arg1 = 0 ;
101914   Dali::Devel::PixelBuffer result;
101915
101916   if (!jarg1) {
101917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101918     return 0;
101919   }
101920   std::string arg1_str(jarg1);
101921   arg1 = &arg1_str;
101922   {
101923     try {
101924       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
101925     } catch (std::out_of_range& e) {
101926       {
101927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101928       };
101929     } catch (std::exception& e) {
101930       {
101931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101932       };
101933     } catch (...) {
101934       {
101935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101936       };
101937     }
101938   }
101939   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101940
101941   return jresult;
101942 }
101943
101944
101945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
101946   void * jresult ;
101947   Dali::Toolkit::WebView result;
101948
101949   {
101950     try {
101951       result = Dali::Toolkit::WebView::New();
101952     } catch (std::out_of_range& e) {
101953       {
101954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101955       };
101956     } catch (std::exception& e) {
101957       {
101958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101959       };
101960     } catch (Dali::DaliException e) {
101961       {
101962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101963       };
101964     } catch (...) {
101965       {
101966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101967       };
101968     }
101969   }
101970   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
101971   return jresult;
101972 }
101973
101974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
101975   void * jresult ;
101976   Dali::Toolkit::WebView result;
101977
101978   std::string *arg1;
101979   std::string *arg2;
101980
101981   if (!jarg1) {
101982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
101983     return 0;
101984   }
101985   if (!jarg2) {
101986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
101987     return 0;
101988   }
101989
101990   std::string jarg1_str = std::string(jarg1);
101991   std::string jarg2_str = std::string(jarg2);
101992
101993   arg1 = &jarg1_str;
101994   arg2 = &jarg2_str;
101995
101996   {
101997     try {
101998       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
101999     } catch (std::out_of_range& e) {
102000       {
102001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102002       };
102003     } catch (std::exception& e) {
102004       {
102005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102006       };
102007     } catch (Dali::DaliException e) {
102008       {
102009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102010       };
102011     } catch (...) {
102012       {
102013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102014       };
102015     }
102016   }
102017   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102018   return jresult;
102019 }
102020
102021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102022   void * jresult ;
102023   Dali::Toolkit::WebView *arg1 = 0 ;
102024   Dali::Toolkit::WebView *result = 0 ;
102025
102026   arg1 = (Dali::Toolkit::WebView *)jarg1;
102027   if (!arg1) {
102028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102029     return 0;
102030   }
102031   {
102032     try {
102033       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102034     } catch (std::out_of_range& e) {
102035       {
102036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102037       };
102038     } catch (std::exception& e) {
102039       {
102040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102041       };
102042     } catch (Dali::DaliException e) {
102043       {
102044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102045       };
102046     } catch (...) {
102047       {
102048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102049       };
102050     }
102051   }
102052   jresult = (void *)result;
102053   return jresult;
102054 }
102055
102056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102057   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102058   arg1 = (Dali::Toolkit::WebView *)jarg1;
102059   {
102060     try {
102061       delete arg1;
102062     } catch (std::out_of_range& e) {
102063       {
102064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102065       };
102066     } catch (std::exception& e) {
102067       {
102068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102069       };
102070     } catch (Dali::DaliException e) {
102071       {
102072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102073       };
102074     } catch (...) {
102075       {
102076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102077       };
102078     }
102079   }
102080 }
102081
102082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102083   void * jresult ;
102084   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102085   Dali::Toolkit::WebView *arg2 = 0 ;
102086   Dali::Toolkit::WebView *result = 0 ;
102087
102088   arg1 = (Dali::Toolkit::WebView *)jarg1;
102089   arg2 = (Dali::Toolkit::WebView *)jarg2;
102090   if (!arg2) {
102091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102092     return 0;
102093   }
102094   {
102095     try {
102096       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102097     } catch (std::out_of_range& e) {
102098       {
102099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102100       };
102101     } catch (std::exception& e) {
102102       {
102103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102104       };
102105     } catch (Dali::DaliException e) {
102106       {
102107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102108       };
102109     } catch (...) {
102110       {
102111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102112       };
102113     }
102114   }
102115   jresult = (void *)result;
102116   return jresult;
102117 }
102118
102119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
102120   void * jresult ;
102121   Dali::BaseHandle arg1 ;
102122   Dali::BaseHandle *argp1 ;
102123   Dali::Toolkit::WebView result;
102124
102125   argp1 = (Dali::BaseHandle *)jarg1;
102126   if (!argp1) {
102127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
102128     return 0;
102129   }
102130   arg1 = *argp1;
102131   {
102132     try {
102133       result = Dali::Toolkit::WebView::DownCast(arg1);
102134     } catch (std::out_of_range& e) {
102135       {
102136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102137       };
102138     } catch (std::exception& e) {
102139       {
102140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102141       };
102142     } catch (Dali::DaliException e) {
102143       {
102144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102145       };
102146     } catch (...) {
102147       {
102148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102149       };
102150     }
102151   }
102152   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102153   return jresult;
102154 }
102155
102156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
102157   return (int) Dali::Toolkit::WebView::Property::URL;
102158 }
102159
102160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
102161   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
102162 }
102163
102164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
102165   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
102166 }
102167
102168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
102169   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
102170 }
102171
102172 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
102173   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
102174 }
102175
102176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
102177   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
102178 }
102179
102180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
102181   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
102182 }
102183
102184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
102185   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
102186 }
102187
102188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
102189   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102190   std::string *arg2;
102191
102192   arg1 = (Dali::Toolkit::WebView *)jarg1;
102193
102194   if (!jarg2) {
102195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102196     return;
102197   }
102198
102199   std::string jarg2str = std::string(jarg2);
102200   arg2 = &jarg2str;
102201   {
102202     try {
102203       (arg1)->LoadUrl((std::string const &)*arg2);
102204     } catch (std::out_of_range& e) {
102205       {
102206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102207       };
102208     } catch (std::exception& e) {
102209       {
102210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102211       };
102212     } catch (Dali::DaliException e) {
102213       {
102214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102215       };
102216     } catch (...) {
102217       {
102218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102219       };
102220     }
102221   }
102222 }
102223
102224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
102225   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102226   std::string *arg2;
102227
102228   arg1 = (Dali::Toolkit::WebView *)jarg1;
102229   if (!jarg2) {
102230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102231     return;
102232   }
102233   std::string jarg2str = std::string(jarg2);
102234   arg2 = &jarg2str;
102235   {
102236     try {
102237       (arg1)->LoadHTMLString((std::string const &)*arg2);
102238     } catch (std::out_of_range& e) {
102239       {
102240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102241       };
102242     } catch (std::exception& e) {
102243       {
102244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102245       };
102246     } catch (Dali::DaliException e) {
102247       {
102248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102249       };
102250     } catch (...) {
102251       {
102252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102253       };
102254     }
102255   }
102256 }
102257
102258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
102259   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102260
102261   arg1 = (Dali::Toolkit::WebView *)jarg1;
102262   {
102263     try {
102264       (arg1)->Reload();
102265     } catch (std::out_of_range& e) {
102266       {
102267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102268       };
102269     } catch (std::exception& e) {
102270       {
102271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102272       };
102273     } catch (Dali::DaliException e) {
102274       {
102275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102276       };
102277     } catch (...) {
102278       {
102279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102280       };
102281     }
102282   }
102283 }
102284
102285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
102286   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102287
102288   arg1 = (Dali::Toolkit::WebView *)jarg1;
102289   {
102290     try {
102291       (arg1)->StopLoading();
102292     } catch (std::out_of_range& e) {
102293       {
102294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102295       };
102296     } catch (std::exception& e) {
102297       {
102298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102299       };
102300     } catch (Dali::DaliException e) {
102301       {
102302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102303       };
102304     } catch (...) {
102305       {
102306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102307       };
102308     }
102309   }
102310 }
102311
102312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
102313   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102314
102315   arg1 = (Dali::Toolkit::WebView *)jarg1;
102316   {
102317     try {
102318       (arg1)->Suspend();
102319     } catch (std::out_of_range& e) {
102320       {
102321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102322       };
102323     } catch (std::exception& e) {
102324       {
102325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102326       };
102327     } catch (Dali::DaliException e) {
102328       {
102329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102330       };
102331     } catch (...) {
102332       {
102333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102334       };
102335     }
102336   }
102337 }
102338
102339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
102340   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102341
102342   arg1 = (Dali::Toolkit::WebView *)jarg1;
102343   {
102344     try {
102345       (arg1)->Resume();
102346     } catch (std::out_of_range& e) {
102347       {
102348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102349       };
102350     } catch (std::exception& e) {
102351       {
102352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102353       };
102354     } catch (Dali::DaliException e) {
102355       {
102356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102357       };
102358     } catch (...) {
102359       {
102360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102361       };
102362     }
102363   }
102364 }
102365
102366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
102367   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102368
102369   arg1 = (Dali::Toolkit::WebView *)jarg1;
102370   {
102371     try {
102372       (arg1)->GoBack();
102373     } catch (std::out_of_range& e) {
102374       {
102375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102376       };
102377     } catch (std::exception& e) {
102378       {
102379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102380       };
102381     } catch (Dali::DaliException e) {
102382       {
102383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102384       };
102385     } catch (...) {
102386       {
102387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102388       };
102389     }
102390   }
102391 }
102392
102393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
102394   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102395
102396   arg1 = (Dali::Toolkit::WebView *)jarg1;
102397   {
102398     try {
102399       (arg1)->GoForward();
102400     } catch (std::out_of_range& e) {
102401       {
102402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102403       };
102404     } catch (std::exception& e) {
102405       {
102406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102407       };
102408     } catch (Dali::DaliException e) {
102409       {
102410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102411       };
102412     } catch (...) {
102413       {
102414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102415       };
102416     }
102417   }
102418 }
102419
102420 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
102421   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102422   bool ret;
102423
102424   arg1 = (Dali::Toolkit::WebView *)jarg1;
102425   {
102426     try {
102427       ret = (arg1)->CanGoBack();
102428     } catch (std::out_of_range& e) {
102429       {
102430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102431       };
102432     } catch (std::exception& e) {
102433       {
102434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102435       };
102436     } catch (Dali::DaliException e) {
102437       {
102438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102439       };
102440     } catch (...) {
102441       {
102442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102443       };
102444     }
102445   }
102446   return ret;
102447 }
102448
102449 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
102450   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102451   bool ret;
102452
102453   arg1 = (Dali::Toolkit::WebView *)jarg1;
102454   {
102455     try {
102456       ret = (arg1)->CanGoForward();
102457     } catch (std::out_of_range& e) {
102458       {
102459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
102460       };
102461     } catch (std::exception& e) {
102462       {
102463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
102464       };
102465     } catch (Dali::DaliException e) {
102466       {
102467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
102468       };
102469     } catch (...) {
102470       {
102471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
102472       };
102473     }
102474   }
102475   return ret;
102476 }
102477
102478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
102479   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102480   std::string *arg2;
102481
102482   arg1 = (Dali::Toolkit::WebView *)jarg1;
102483   if (!jarg2) {
102484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102485     return;
102486   }
102487   std::string jarg2_str = std::string(jarg2);
102488   arg2 = &jarg2_str;
102489
102490   {
102491     try {
102492       if (jarg3) {
102493         void (*handler)(char*) = (void (*)(char*)) jarg3;
102494         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
102495           handler(SWIG_csharp_string_callback(result.c_str()));
102496         });
102497       } else {
102498         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
102499       }
102500     } catch (std::out_of_range& e) {
102501       {
102502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102503       };
102504     } catch (std::exception& e) {
102505       {
102506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102507       };
102508     } catch (Dali::DaliException e) {
102509       {
102510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102511       };
102512     } catch (...) {
102513       {
102514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102515       };
102516     }
102517   }
102518 }
102519
102520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
102521 {
102522   if (!jarg2) {
102523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102524     return;
102525   }
102526
102527   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102528   std::string exposedObjectName = jarg2;
102529   void (*handler)(char*) = (void (*)(char*)) jarg3;
102530
102531   {
102532     try {
102533       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
102534         handler(SWIG_csharp_string_callback(message.c_str()));
102535       });
102536     } catch (std::out_of_range& e) {
102537       {
102538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102539       };
102540     } catch (std::exception& e) {
102541       {
102542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102543       };
102544     } catch (Dali::DaliException e) {
102545       {
102546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102547       };
102548     } catch (...) {
102549       {
102550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102551       };
102552     }
102553   }
102554 }
102555
102556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
102557   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102558
102559   arg1 = (Dali::Toolkit::WebView *)jarg1;
102560   {
102561     try {
102562       (arg1)->ClearHistory();
102563     } catch (std::out_of_range& e) {
102564       {
102565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102566       };
102567     } catch (std::exception& e) {
102568       {
102569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102570       };
102571     } catch (Dali::DaliException e) {
102572       {
102573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102574       };
102575     } catch (...) {
102576       {
102577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102578       };
102579     }
102580   }
102581 }
102582
102583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
102584   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102585
102586   arg1 = (Dali::Toolkit::WebView *)jarg1;
102587   {
102588     try {
102589       (arg1)->ClearCache();
102590     } catch (std::out_of_range& e) {
102591       {
102592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102593       };
102594     } catch (std::exception& e) {
102595       {
102596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102597       };
102598     } catch (Dali::DaliException e) {
102599       {
102600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102601       };
102602     } catch (...) {
102603       {
102604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102605       };
102606     }
102607   }
102608 }
102609
102610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
102611   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102612
102613   arg1 = (Dali::Toolkit::WebView *)jarg1;
102614   {
102615     try {
102616       (arg1)->ClearCookies();
102617     } catch (std::out_of_range& e) {
102618       {
102619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102620       };
102621     } catch (std::exception& e) {
102622       {
102623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102624       };
102625     } catch (Dali::DaliException e) {
102626       {
102627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102628       };
102629     } catch (...) {
102630       {
102631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102632       };
102633     }
102634   }
102635 }
102636
102637 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
102638     return (Dali::Toolkit::Control *)jarg1;
102639 }
102640
102641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
102642   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102643   SignalConverter::WebViewPageLoadSignal* result = NULL;
102644   {
102645     try {
102646       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
102647     } catch (std::out_of_range& e) {
102648       {
102649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102650       };
102651     } catch (std::exception& e) {
102652       {
102653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102654       };
102655     } catch (Dali::DaliException e) {
102656       {
102657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102658       };
102659     } catch (...) {
102660       {
102661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102662       };
102663     }
102664   }
102665   return (void*) result;
102666 }
102667
102668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
102669   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102670   SignalConverter::WebViewPageLoadSignal* result = NULL;
102671   {
102672     try {
102673       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
102674     } catch (std::out_of_range& e) {
102675       {
102676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102677       };
102678     } catch (std::exception& e) {
102679       {
102680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102681       };
102682     } catch (Dali::DaliException e) {
102683       {
102684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102685       };
102686     } catch (...) {
102687       {
102688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102689       };
102690     }
102691   }
102692   return (void*) result;
102693 }
102694
102695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
102696 {
102697   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102698   {
102699     try {
102700       delete object;
102701     } catch (std::out_of_range& e) {
102702       {
102703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102704       };
102705     } catch (std::exception& e) {
102706       {
102707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102708       };
102709     } catch (Dali::DaliException e) {
102710       {
102711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102712       };
102713     } catch (...) {
102714       {
102715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102716       };
102717     }
102718   }
102719 }
102720
102721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
102722 {
102723   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102724   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102725   {
102726     try {
102727       proxy->Connect(callback);
102728     } catch (std::out_of_range& e) {
102729       {
102730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102731       };
102732     } catch (std::exception& e) {
102733       {
102734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102735       };
102736     } catch (Dali::DaliException e) {
102737       {
102738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102739       };
102740     } catch (...) {
102741       {
102742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102743       };
102744     }
102745   }
102746 }
102747
102748
102749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
102750   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
102751   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
102752   {
102753     try {
102754       proxy->Disconnect(callback);
102755     } catch (std::out_of_range& e) {
102756       {
102757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102758       };
102759     } catch (std::exception& e) {
102760       {
102761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102762       };
102763     } catch (Dali::DaliException e) {
102764       {
102765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102766       };
102767     } catch (...) {
102768       {
102769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102770       };
102771     }
102772   }
102773 }
102774
102775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
102776   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
102777   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
102778   {
102779     try {
102780       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
102781     } catch (std::out_of_range& e) {
102782       {
102783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102784       };
102785     } catch (std::exception& e) {
102786       {
102787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102788       };
102789     } catch (Dali::DaliException e) {
102790       {
102791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102792       };
102793     } catch (...) {
102794       {
102795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102796       };
102797     }
102798   }
102799   return (void*) result;
102800 }
102801
102802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
102803 {
102804   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102805   {
102806     try {
102807       delete object;
102808     } catch (std::out_of_range& e) {
102809       {
102810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102811       };
102812     } catch (std::exception& e) {
102813       {
102814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102815       };
102816     } catch (Dali::DaliException e) {
102817       {
102818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102819       };
102820     } catch (...) {
102821       {
102822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102823       };
102824     }
102825   }
102826 }
102827
102828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
102829 {
102830   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102831   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102832   {
102833     try {
102834       proxy->Connect(callback);
102835     } catch (std::out_of_range& e) {
102836       {
102837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102838       };
102839     } catch (std::exception& e) {
102840       {
102841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102842       };
102843     } catch (Dali::DaliException e) {
102844       {
102845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102846       };
102847     } catch (...) {
102848       {
102849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102850       };
102851     }
102852   }
102853 }
102854
102855
102856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
102857   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
102858   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
102859   {
102860     try {
102861       proxy->Disconnect(callback);
102862     } catch (std::out_of_range& e) {
102863       {
102864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102865       };
102866     } catch (std::exception& e) {
102867       {
102868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102869       };
102870     } catch (Dali::DaliException e) {
102871       {
102872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102873       };
102874     } catch (...) {
102875       {
102876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102877       };
102878     }
102879   }
102880 }
102881
102882 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
102883   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
102884   char * jresult = SWIG_csharp_string_callback((const char *)result);
102885   return jresult;
102886 }
102887
102888 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
102889   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
102890   return result;
102891 }
102892
102893 #ifdef __cplusplus
102894 }
102895 #endif
102896